;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case testinput from PCRE.
;;;
;;; This file is automatically generated from PCRE's test data with
;;; Perl 5.008004 at 2004-05-24 17:41:51 UTC.
;;;
;;; See: http://www.pcre.org/ for PCRE, Perl Compatible Regex.
;;;
;

;;;; testinput/2: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2"
  "the quick brown fox"
  "the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput/3: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3"
  "the quick brown fox"
  "The quick brown FOX"
  '(:single-line nil)
  nil
 )

;;;; testinput/4: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/4"
  "the quick brown fox"
  "What do you know about the quick brown fox?"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput/5: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/5"
  "the quick brown fox"
  "What do you know about THE QUICK BROWN FOX?"
  '(:single-line nil)
  nil
 )

;;;; testinput/8: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/8"
  "The quick brown fox"
  "the quick brown fox"
  '(:ignore-case t :single-line nil)
  (list "the quick brown fox") )

;;;; testinput/9: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/9"
  "The quick brown fox"
  "The quick brown FOX"
  '(:ignore-case t :single-line nil)
  (list "The quick brown FOX") )

;;;; testinput/10: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/10"
  "The quick brown fox"
  "What do you know about the quick brown fox?"
  '(:ignore-case t :single-line nil)
  (list "the quick brown fox") )

;;;; testinput/11: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/11"
  "The quick brown fox"
  "What do you know about THE QUICK BROWN FOX?"
  '(:ignore-case t :single-line nil)
  (list "THE QUICK BROWN FOX") )

;;;; testinput/14: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/14"
  "abcd\\t\\n\\r\\f\\a\\e\\071\\x3b\\$\\\\\\?caxyz"
  (backslash "abcd\\t\\n\\u000D\\u000C\\u0007\\u001B9;$\\?caxyz")
  '(:single-line nil)
  (list (backslash "abcd\\t\\n\\u000D\\u000C\\u0007\\u001B9;$\\?caxyz")) )

;;;; testinput/17: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/17"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/18: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/18"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/19: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/19"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/20: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/20"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/21: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/21"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/22: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/22"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/23: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/23"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/24: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/24"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypAzz") )

;;;; testinput/25: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/25"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/26: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/26"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqAzz") )

;;;; testinput/27: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/27"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqAzz") )

;;;; testinput/28: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/28"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqAzz") )

;;;; testinput/29: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/29"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqqAzz") )

;;;; testinput/30: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/30"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqqqAzz") )

;;;; testinput/31: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/31"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/32: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/32"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzzpqrrrabbxyyyypqAzz") )

;;;; testinput/33: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/33"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabxyzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabxyzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/34: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/34"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/35: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/35"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/36: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/36"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abcxyzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzzpqrrrabbxyyyypqAzz") )

;;;; testinput/37: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/37"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabcxyzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabcxyzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/38: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/38"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabcxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/39: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/39"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput/40: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/40"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbbxyyyypqAzz") )

;;;; testinput/41: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/41"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz") )

;;;; testinput/42: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/42"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypABzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypABzz") )

;;;; testinput/43: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/43"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypABBzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypABBzz") )

;;;; testinput/44: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/44"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">>>aaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/45: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/45"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">aaaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/46: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/46"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">>>>abcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput/47: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/47"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrabbxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/48: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/48"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrrabbxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/49: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/49"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/50: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/50"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/51: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/51"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/52: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/52"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqqqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput/55: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/55"
  "^(abc){1,2}zz"
  "abczz"
  '(:single-line nil)
  (list
    "abczz"
    "abc" ) )

;;;; testinput/56: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/56"
  "^(abc){1,2}zz"
  "abcabczz"
  '(:single-line nil)
  (list
    "abcabczz"
    "abc" ) )

;;;; testinput/57: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/57"
  "^(abc){1,2}zz"
  "zz"
  '(:single-line nil)
  nil
 )

;;;; testinput/58: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/58"
  "^(abc){1,2}zz"
  "abcabcabczz"
  '(:single-line nil)
  nil
 )

;;;; testinput/59: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/59"
  "^(abc){1,2}zz"
  ">>abczz"
  '(:single-line nil)
  nil
 )

;;;; testinput/62: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/62"
  "^(b+?|a){1,2}?c"
  "bc"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; testinput/63: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/63"
  "^(b+?|a){1,2}?c"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "b" ) )

;;;; testinput/64: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/64"
  "^(b+?|a){1,2}?c"
  "bbbc"
  '(:single-line nil)
  (list
    "bbbc"
    "bb" ) )

;;;; testinput/65: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/65"
  "^(b+?|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput/66: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/66"
  "^(b+?|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput/67: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/67"
  "^(b+?|a){1,2}?c"
  "aac"
  '(:single-line nil)
  (list
    "aac"
    "a" ) )

;;;; testinput/68: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/68"
  "^(b+?|a){1,2}?c"
  "abbbbbbbbbbbc"
  '(:single-line nil)
  (list
    "abbbbbbbbbbbc"
    "bbbbbbbbbbb" ) )

;;;; testinput/69: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/69"
  "^(b+?|a){1,2}?c"
  "bbbbbbbbbbbac"
  '(:single-line nil)
  (list
    "bbbbbbbbbbbac"
    "a" ) )

;;;; testinput/70: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/70"
  "^(b+?|a){1,2}?c"
  "aaac"
  '(:single-line nil)
  nil
 )

;;;; testinput/71: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/71"
  "^(b+?|a){1,2}?c"
  "abbbbbbbbbbbac"
  '(:single-line nil)
  nil
 )

;;;; testinput/74: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/74"
  "^(b+|a){1,2}c"
  "bc"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; testinput/75: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/75"
  "^(b+|a){1,2}c"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "bb" ) )

;;;; testinput/76: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/76"
  "^(b+|a){1,2}c"
  "bbbc"
  '(:single-line nil)
  (list
    "bbbc"
    "bbb" ) )

;;;; testinput/77: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/77"
  "^(b+|a){1,2}c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput/78: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/78"
  "^(b+|a){1,2}c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput/79: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/79"
  "^(b+|a){1,2}c"
  "aac"
  '(:single-line nil)
  (list
    "aac"
    "a" ) )

;;;; testinput/80: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/80"
  "^(b+|a){1,2}c"
  "abbbbbbbbbbbc"
  '(:single-line nil)
  (list
    "abbbbbbbbbbbc"
    "bbbbbbbbbbb" ) )

;;;; testinput/81: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/81"
  "^(b+|a){1,2}c"
  "bbbbbbbbbbbac"
  '(:single-line nil)
  (list
    "bbbbbbbbbbbac"
    "a" ) )

;;;; testinput/82: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/82"
  "^(b+|a){1,2}c"
  "aaac"
  '(:single-line nil)
  nil
 )

;;;; testinput/83: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/83"
  "^(b+|a){1,2}c"
  "abbbbbbbbbbbac"
  '(:single-line nil)
  nil
 )

;;;; testinput/86: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/86"
  "^(b+|a){1,2}?bc"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "b" ) )

;;;; testinput/89: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/89"
  "^(b*|ba){1,2}?bc"
  "babc"
  '(:single-line nil)
  (list
    "babc"
    "ba" ) )

;;;; testinput/90: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/90"
  "^(b*|ba){1,2}?bc"
  "bbabc"
  '(:single-line nil)
  (list
    "bbabc"
    "ba" ) )

;;;; testinput/91: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/91"
  "^(b*|ba){1,2}?bc"
  "bababc"
  '(:single-line nil)
  (list
    "bababc"
    "ba" ) )

;;;; testinput/92: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/92"
  "^(b*|ba){1,2}?bc"
  "bababbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/93: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/93"
  "^(b*|ba){1,2}?bc"
  "babababc"
  '(:single-line nil)
  nil
 )

;;;; testinput/96: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/96"
  "^(ba|b*){1,2}?bc"
  "babc"
  '(:single-line nil)
  (list
    "babc"
    "ba" ) )

;;;; testinput/97: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/97"
  "^(ba|b*){1,2}?bc"
  "bbabc"
  '(:single-line nil)
  (list
    "bbabc"
    "ba" ) )

;;;; testinput/98: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/98"
  "^(ba|b*){1,2}?bc"
  "bababc"
  '(:single-line nil)
  (list
    "bababc"
    "ba" ) )

;;;; testinput/99: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/99"
  "^(ba|b*){1,2}?bc"
  "bababbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/100: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/100"
  "^(ba|b*){1,2}?bc"
  "babababc"
  '(:single-line nil)
  nil
 )

;;;; testinput/103: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/103"
  "^\\ca\\cA\\c[\\c{\\c:"
  (backslash "\\u0001\\u0001\\u001B;z")
  '(:single-line nil)
  (list (backslash "\\u0001\\u0001\\u001B;z")) )

;;;; testinput/106: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/106"
  "^[ab\\]cde]"
  "athing"
  '(:single-line nil)
  (list "a") )

;;;; testinput/107: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/107"
  "^[ab\\]cde]"
  "bthing"
  '(:single-line nil)
  (list "b") )

;;;; testinput/108: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/108"
  "^[ab\\]cde]"
  "]thing"
  '(:single-line nil)
  (list "]") )

;;;; testinput/109: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/109"
  "^[ab\\]cde]"
  "cthing"
  '(:single-line nil)
  (list "c") )

;;;; testinput/110: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/110"
  "^[ab\\]cde]"
  "dthing"
  '(:single-line nil)
  (list "d") )

;;;; testinput/111: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/111"
  "^[ab\\]cde]"
  "ething"
  '(:single-line nil)
  (list "e") )

;;;; testinput/112: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/112"
  "^[ab\\]cde]"
  "fthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/113: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/113"
  "^[ab\\]cde]"
  "[thing"
  '(:single-line nil)
  nil
 )

;;;; testinput/114: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/114"
  "^[ab\\]cde]"
  "\\thing"
  '(:single-line nil)
  nil
 )

;;;; testinput/117: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/117"
  "^[]cde]"
  "]thing"
  '(:single-line nil)
  (list "]") )

;;;; testinput/118: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/118"
  "^[]cde]"
  "cthing"
  '(:single-line nil)
  (list "c") )

;;;; testinput/119: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/119"
  "^[]cde]"
  "dthing"
  '(:single-line nil)
  (list "d") )

;;;; testinput/120: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/120"
  "^[]cde]"
  "ething"
  '(:single-line nil)
  (list "e") )

;;;; testinput/121: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/121"
  "^[]cde]"
  "athing"
  '(:single-line nil)
  nil
 )

;;;; testinput/122: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/122"
  "^[]cde]"
  "fthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/125: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/125"
  "^[^ab\\]cde]"
  "fthing"
  '(:single-line nil)
  (list "f") )

;;;; testinput/126: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/126"
  "^[^ab\\]cde]"
  "[thing"
  '(:single-line nil)
  (list "[") )

;;;; testinput/127: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/127"
  "^[^ab\\]cde]"
  "\\thing"
  '(:single-line nil)
  (list "\\") )

;;;; testinput/128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/128"
  "^[^ab\\]cde]"
  "athing"
  '(:single-line nil)
  nil
 )

;;;; testinput/129: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/129"
  "^[^ab\\]cde]"
  "bthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/130: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/130"
  "^[^ab\\]cde]"
  "]thing"
  '(:single-line nil)
  nil
 )

;;;; testinput/131: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/131"
  "^[^ab\\]cde]"
  "cthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/132: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/132"
  "^[^ab\\]cde]"
  "dthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/133: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/133"
  "^[^ab\\]cde]"
  "ething"
  '(:single-line nil)
  nil
 )

;;;; testinput/136: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/136"
  "^[^]cde]"
  "athing"
  '(:single-line nil)
  (list "a") )

;;;; testinput/137: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/137"
  "^[^]cde]"
  "fthing"
  '(:single-line nil)
  (list "f") )

;;;; testinput/138: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/138"
  "^[^]cde]"
  "]thing"
  '(:single-line nil)
  nil
 )

;;;; testinput/139: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/139"
  "^[^]cde]"
  "cthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/140: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/140"
  "^[^]cde]"
  "dthing"
  '(:single-line nil)
  nil
 )

;;;; testinput/141: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/141"
  "^[^]cde]"
  "ething"
  '(:single-line nil)
  nil
 )

;;;; testinput/144: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/144"
  (backslash "^\\\\u0081")
  (backslash "\\u0081")
  '(:single-line nil)
  (list (backslash "\\u0081")) )

;;;; testinput/147: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/147"
  (backslash "^\\u00FF")
  (backslash "\\u00FF")
  '(:single-line nil)
  (list (backslash "\\u00FF")) )

;;;; testinput/150: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/150"
  "^[0-9]+$"
  "0"
  '(:single-line nil)
  (list "0") )

;;;; testinput/151: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/151"
  "^[0-9]+$"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput/152: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/152"
  "^[0-9]+$"
  "2"
  '(:single-line nil)
  (list "2") )

;;;; testinput/153: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/153"
  "^[0-9]+$"
  "3"
  '(:single-line nil)
  (list "3") )

;;;; testinput/154: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/154"
  "^[0-9]+$"
  "4"
  '(:single-line nil)
  (list "4") )

;;;; testinput/155: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/155"
  "^[0-9]+$"
  "5"
  '(:single-line nil)
  (list "5") )

;;;; testinput/156: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/156"
  "^[0-9]+$"
  "6"
  '(:single-line nil)
  (list "6") )

;;;; testinput/157: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/157"
  "^[0-9]+$"
  "7"
  '(:single-line nil)
  (list "7") )

;;;; testinput/158: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/158"
  "^[0-9]+$"
  "8"
  '(:single-line nil)
  (list "8") )

;;;; testinput/159: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/159"
  "^[0-9]+$"
  "9"
  '(:single-line nil)
  (list "9") )

;;;; testinput/160: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/160"
  "^[0-9]+$"
  "10"
  '(:single-line nil)
  (list "10") )

;;;; testinput/161: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/161"
  "^[0-9]+$"
  "100"
  '(:single-line nil)
  (list "100") )

;;;; testinput/162: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/162"
  "^[0-9]+$"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/165: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/165"
  "^.*nter"
  "enter"
  '(:single-line nil)
  (list "enter") )

;;;; testinput/166: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/166"
  "^.*nter"
  "inter"
  '(:single-line nil)
  (list "inter") )

;;;; testinput/167: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/167"
  "^.*nter"
  "uponter"
  '(:single-line nil)
  (list "uponter") )

;;;; testinput/170: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/170"
  "^xxx[0-9]+$"
  "xxx0"
  '(:single-line nil)
  (list "xxx0") )

;;;; testinput/171: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/171"
  "^xxx[0-9]+$"
  "xxx1234"
  '(:single-line nil)
  (list "xxx1234") )

;;;; testinput/172: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/172"
  "^xxx[0-9]+$"
  "xxx"
  '(:single-line nil)
  nil
 )

;;;; testinput/175: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/175"
  "^.+[0-9][0-9][0-9]$"
  "x123"
  '(:single-line nil)
  (list "x123") )

;;;; testinput/176: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/176"
  "^.+[0-9][0-9][0-9]$"
  "xx123"
  '(:single-line nil)
  (list "xx123") )

;;;; testinput/177: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/177"
  "^.+[0-9][0-9][0-9]$"
  "123456"
  '(:single-line nil)
  (list "123456") )

;;;; testinput/178: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/178"
  "^.+[0-9][0-9][0-9]$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput/179: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/179"
  "^.+[0-9][0-9][0-9]$"
  "x1234"
  '(:single-line nil)
  (list "x1234") )

;;;; testinput/182: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/182"
  "^.+?[0-9][0-9][0-9]$"
  "x123"
  '(:single-line nil)
  (list "x123") )

;;;; testinput/183: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/183"
  "^.+?[0-9][0-9][0-9]$"
  "xx123"
  '(:single-line nil)
  (list "xx123") )

;;;; testinput/184: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/184"
  "^.+?[0-9][0-9][0-9]$"
  "123456"
  '(:single-line nil)
  (list "123456") )

;;;; testinput/185: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/185"
  "^.+?[0-9][0-9][0-9]$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput/186: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/186"
  "^.+?[0-9][0-9][0-9]$"
  "x1234"
  '(:single-line nil)
  (list "x1234") )

;;;; testinput/189: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/189"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  (list
    "abc!pqr=apquxz.ixr.zzz.ac.uk"
    "abc"
    "pqr" ) )

;;;; testinput/190: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/190"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "!pqr=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput/191: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/191"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput/192: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/192"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz:ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput/193: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/193"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz.ixr.zzz.ac.ukk"
  '(:single-line nil)
  nil
 )

;;;; testinput/196: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/196"
  ":"
  "Well, we need a colon: somewhere"
  '(:single-line nil)
  (list ":") )

;;;; testinput/197: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/197"
  ":"
  "Fail if we don't"
  '(:single-line nil)
  nil
 )

;;;; testinput/200: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/200"
  "([\\da-f:]+)$"
  "0abc"
  '(:ignore-case t :single-line nil)
  (list
    "0abc"
    "0abc" ) )

;;;; testinput/201: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/201"
  "([\\da-f:]+)$"
  "abc"
  '(:ignore-case t :single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; testinput/202: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/202"
  "([\\da-f:]+)$"
  "fed"
  '(:ignore-case t :single-line nil)
  (list
    "fed"
    "fed" ) )

;;;; testinput/203: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/203"
  "([\\da-f:]+)$"
  "E"
  '(:ignore-case t :single-line nil)
  (list
    "E"
    "E" ) )

;;;; testinput/204: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/204"
  "([\\da-f:]+)$"
  "::"
  '(:ignore-case t :single-line nil)
  (list
    "::"
    "::" ) )

;;;; testinput/205: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/205"
  "([\\da-f:]+)$"
  "5f03:12C0::932e"
  '(:ignore-case t :single-line nil)
  (list
    "5f03:12C0::932e"
    "5f03:12C0::932e" ) )

;;;; testinput/206: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/206"
  "([\\da-f:]+)$"
  "fed def"
  '(:ignore-case t :single-line nil)
  (list
    "def"
    "def" ) )

;;;; testinput/207: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/207"
  "([\\da-f:]+)$"
  "Any old stuff"
  '(:ignore-case t :single-line nil)
  (list
    "ff"
    "ff" ) )

;;;; testinput/208: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/208"
  "([\\da-f:]+)$"
  "0zzz"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/209: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/209"
  "([\\da-f:]+)$"
  "gzzz"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/210: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/210"
  "([\\da-f:]+)$"
  "fed "
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/211: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/211"
  "([\\da-f:]+)$"
  "Any old rubbish"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/214: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/214"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  ".1.2.3"
  '(:single-line nil)
  (list
    ".1.2.3"
    "1"
    "2"
    "3" ) )

;;;; testinput/215: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/215"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "A.12.123.0"
  '(:single-line nil)
  (list
    "A.12.123.0"
    "12"
    "123"
    "0" ) )

;;;; testinput/216: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/216"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  ".1.2.3333"
  '(:single-line nil)
  nil
 )

;;;; testinput/217: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/217"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "1.2.3"
  '(:single-line nil)
  nil
 )

;;;; testinput/218: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/218"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "1234.2.3"
  '(:single-line nil)
  nil
 )

;;;; testinput/221: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/221"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1 IN SOA non-sp1 non-sp2("
  '(:single-line nil)
  (list
    "1 IN SOA non-sp1 non-sp2("
    "1"
    "non-sp1"
    "non-sp2" ) )

;;;; testinput/222: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/222"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1    IN    SOA    non-sp1    non-sp2   ("
  '(:single-line nil)
  (list
    "1    IN    SOA    non-sp1    non-sp2   ("
    "1"
    "non-sp1"
    "non-sp2" ) )

;;;; testinput/223: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/223"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1IN SOA non-sp1 non-sp2("
  '(:single-line nil)
  nil
 )

;;;; testinput/226: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/226"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "a."
  '(:single-line nil)
  (list "a.") )

;;;; testinput/227: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/227"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "Z."
  '(:single-line nil)
  (list "Z.") )

;;;; testinput/228: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/228"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "2."
  '(:single-line nil)
  (list "2.") )

;;;; testinput/229: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/229"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "ab-c.pq-r."
  '(:single-line nil)
  (list
    "ab-c.pq-r."
    ".pq-r" ) )

;;;; testinput/230: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/230"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "sxk.zzz.ac.uk."
  '(:single-line nil)
  (list
    "sxk.zzz.ac.uk."
    ".uk" ) )

;;;; testinput/231: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/231"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "x-.y-."
  '(:single-line nil)
  (list
    "x-.y-."
    ".y-" ) )

;;;; testinput/232: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/232"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "-abc.peq."
  '(:single-line nil)
  nil
 )

;;;; testinput/235: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/235"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a"
  '(:single-line nil)
  (list "*.a") )

;;;; testinput/236: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/236"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.b0-a"
  '(:single-line nil)
  (list
    "*.b0-a"
    "0-a" ) )

;;;; testinput/237: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/237"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c3-b.c"
  '(:single-line nil)
  (list
    "*.c3-b.c"
    "3-b"
    ".c" ) )

;;;; testinput/238: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/238"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c-a.b-c"
  '(:single-line nil)
  (list
    "*.c-a.b-c"
    "-a"
    ".b-c"
    "-c" ) )

;;;; testinput/239: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/239"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.0"
  '(:single-line nil)
  nil
 )

;;;; testinput/240: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/240"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a-"
  '(:single-line nil)
  nil
 )

;;;; testinput/241: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/241"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a-b.c-"
  '(:single-line nil)
  nil
 )

;;;; testinput/242: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/242"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c-a.0-c"
  '(:single-line nil)
  nil
 )

;;;; testinput/245: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/245"
  "^(?=ab(de))(abd)(e)"
  "abde"
  '(:single-line nil)
  (list
    "abde"
    "de"
    "abd"
    "e" ) )

;;;; testinput/248: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/248"
  "^(?!(ab)de|x)(abd)(f)"
  "abdf"
  '(:single-line nil)
  (list
    "abdf"
    nil
    "abd"
    "f" ) )

;;;; testinput/251: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/251"
  "^(?=(ab(cd)))(ab)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "abcd"
    "cd"
    "ab" ) )

;;;; testinput/254: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/254"
  "^[\\da-f](\\.[\\da-f])*$"
  "a.b.c.d"
  '(:ignore-case t :single-line nil)
  (list
    "a.b.c.d"
    ".d" ) )

;;;; testinput/255: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/255"
  "^[\\da-f](\\.[\\da-f])*$"
  "A.B.C.D"
  '(:ignore-case t :single-line nil)
  (list
    "A.B.C.D"
    ".D" ) )

;;;; testinput/256: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/256"
  "^[\\da-f](\\.[\\da-f])*$"
  "a.b.c.1.2.3.C"
  '(:ignore-case t :single-line nil)
  (list
    "a.b.c.1.2.3.C"
    ".C" ) )

;;;; testinput/259: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/259"
  "^\".*\"\\s*(;.*)?$"
  "\"1234\""
  '(:single-line nil)
  (list "\"1234\"") )

;;;; testinput/260: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/260"
  "^\".*\"\\s*(;.*)?$"
  "\"abcd\" ;"
  '(:single-line nil)
  (list
    "\"abcd\" ;"
    ";" ) )

;;;; testinput/261: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/261"
  "^\".*\"\\s*(;.*)?$"
  "\"\" ; rhubarb"
  '(:single-line nil)
  (list
    "\"\" ; rhubarb"
    "; rhubarb" ) )

;;;; testinput/262: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/262"
  "^\".*\"\\s*(;.*)?$"
  "\"1234\" : things"
  '(:single-line nil)
  nil
 )

;;;; testinput/265: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/265"
  "^$"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput/268: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/268"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab c"
  '(:extended-syntax t :single-line nil)
  (list "ab c") )

;;;; testinput/269: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/269"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "abc"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/270: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/270"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab cde"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/273: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/273"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab c"
  '(:single-line nil)
  (list "ab c") )

;;;; testinput/274: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/274"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/275: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/275"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab cde"
  '(:single-line nil)
  nil
 )

;;;; testinput/278: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/278"
  "^   a\\ b[c ]d       $"
  "a bcd"
  '(:extended-syntax t :single-line nil)
  (list "a bcd") )

;;;; testinput/279: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/279"
  "^   a\\ b[c ]d       $"
  "a b d"
  '(:extended-syntax t :single-line nil)
  (list "a b d") )

;;;; testinput/280: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/280"
  "^   a\\ b[c ]d       $"
  "abcd"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/281: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/281"
  "^   a\\ b[c ]d       $"
  "ab d"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/284: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-cl/284"
  "^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$"
  "abcdefhijklm"
  '(:single-line nil)
  (list
    "abcdefhijklm"
    "abc"
    "bc"
    "c"
    "def"
    "ef"
    "f"
    "hij"
    "ij"
    "j"
    "klm"
    "lm"
    "m" ) )

;;;; testinput/287: 
;;;
;;;    Matched with 8 captures.
;
(test-case
  "pcre-cl/287"
  "^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$"
  "abcdefhijklm"
  '(:single-line nil)
  (list
    "abcdefhijklm"
    "bc"
    "c"
    "ef"
    "f"
    "ij"
    "j"
    "lm"
    "m" ) )

;;;; testinput/290: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/290"
  "^[\\w][\\W][\\s][\\S][\\d][\\D][\\b][\\n][\\c]][\\022]"
  (backslash "a+ Z0+\\u0008\\n\\u001D\\u0012")
  '(:single-line nil)
  (list (backslash "a+ Z0+\\u0008\\n\\u001D\\u0012")) )

;;;; testinput/293: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/293"
  "^[.^$|()*+?{,}]+"
  ".^$(*+)|{?,?}"
  '(:single-line nil)
  (list ".^$(*+)|{?,?}") )

;;;; testinput/296: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/296"
  "^a*\\w"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput/297: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/297"
  "^a*\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput/298: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/298"
  "^a*\\w"
  "aaaz"
  '(:single-line nil)
  (list "aaaz") )

;;;; testinput/299: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/299"
  "^a*\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/300: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/300"
  "^a*\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/301: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/301"
  "^a*\\w"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput/302: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/302"
  "^a*\\w"
  "a+"
  '(:single-line nil)
  (list "a") )

;;;; testinput/303: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/303"
  "^a*\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/306: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/306"
  "^a*?\\w"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput/307: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/307"
  "^a*?\\w"
  "az"
  '(:single-line nil)
  (list "a") )

;;;; testinput/308: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/308"
  "^a*?\\w"
  "aaaz"
  '(:single-line nil)
  (list "a") )

;;;; testinput/309: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/309"
  "^a*?\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/310: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/310"
  "^a*?\\w"
  "aa"
  '(:single-line nil)
  (list "a") )

;;;; testinput/311: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/311"
  "^a*?\\w"
  "aaaa"
  '(:single-line nil)
  (list "a") )

;;;; testinput/312: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/312"
  "^a*?\\w"
  "a+"
  '(:single-line nil)
  (list "a") )

;;;; testinput/313: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/313"
  "^a*?\\w"
  "aa+"
  '(:single-line nil)
  (list "a") )

;;;; testinput/316: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/316"
  "^a+\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput/317: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/317"
  "^a+\\w"
  "aaaz"
  '(:single-line nil)
  (list "aaaz") )

;;;; testinput/318: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/318"
  "^a+\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/319: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/319"
  "^a+\\w"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput/320: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/320"
  "^a+\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/323: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/323"
  "^a+?\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput/324: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/324"
  "^a+?\\w"
  "aaaz"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/325: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/325"
  "^a+?\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/326: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/326"
  "^a+?\\w"
  "aaaa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/327: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/327"
  "^a+?\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/330: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/330"
  "^\\d{8}\\w{2,}"
  "1234567890"
  '(:single-line nil)
  (list "1234567890") )

;;;; testinput/331: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/331"
  "^\\d{8}\\w{2,}"
  "12345678ab"
  '(:single-line nil)
  (list "12345678ab") )

;;;; testinput/332: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/332"
  "^\\d{8}\\w{2,}"
  "12345678__"
  '(:single-line nil)
  (list "12345678__") )

;;;; testinput/333: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/333"
  "^\\d{8}\\w{2,}"
  "1234567"
  '(:single-line nil)
  nil
 )

;;;; testinput/336: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/336"
  "^[aeiou\\d]{4,5}$"
  "uoie"
  '(:single-line nil)
  (list "uoie") )

;;;; testinput/337: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/337"
  "^[aeiou\\d]{4,5}$"
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput/338: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/338"
  "^[aeiou\\d]{4,5}$"
  "12345"
  '(:single-line nil)
  (list "12345") )

;;;; testinput/339: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/339"
  "^[aeiou\\d]{4,5}$"
  "aaaaa"
  '(:single-line nil)
  (list "aaaaa") )

;;;; testinput/340: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/340"
  "^[aeiou\\d]{4,5}$"
  "123456"
  '(:single-line nil)
  nil
 )

;;;; testinput/343: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/343"
  "^[aeiou\\d]{4,5}?"
  "uoie"
  '(:single-line nil)
  (list "uoie") )

;;;; testinput/344: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/344"
  "^[aeiou\\d]{4,5}?"
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput/345: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/345"
  "^[aeiou\\d]{4,5}?"
  "12345"
  '(:single-line nil)
  (list "1234") )

;;;; testinput/346: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/346"
  "^[aeiou\\d]{4,5}?"
  "aaaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput/347: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/347"
  "^[aeiou\\d]{4,5}?"
  "123456"
  '(:single-line nil)
  (list "1234") )

;;;; testinput/350: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/350"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "abc=abcabc"
  '(:single-line nil)
  (list
    "abc=abcabc"
    "abc"
    "abc" ) )

;;;; testinput/351: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/351"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "def=defdefdef"
  '(:single-line nil)
  (list
    "def=defdefdef"
    "def"
    "def" ) )

;;;; testinput/352: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/352"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "abc=defdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/355: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-cl/355"
  "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$"
  "abcdefghijkcda2"
  '(:single-line nil)
  (list
    "abcdefghijkcda2"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "cd" ) )

;;;; testinput/356: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-cl/356"
  "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$"
  "abcdefghijkkkkcda2"
  '(:single-line nil)
  (list
    "abcdefghijkkkkcda2"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "cd" ) )

;;;; testinput/359: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-cl/359"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "cataract cataract23"
  '(:single-line nil)
  (list
    "cataract cataract23"
    "cataract"
    "aract"
    "ract"
    ""
    "3" ) )

;;;; testinput/360: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-cl/360"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "catatonic catatonic23"
  '(:single-line nil)
  (list
    "catatonic catatonic23"
    "catatonic"
    "atonic"
    "tonic"
    ""
    "3" ) )

;;;; testinput/361: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-cl/361"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "caterpillar caterpillar23"
  '(:single-line nil)
  (list
    "caterpillar caterpillar23"
    "caterpillar"
    "erpillar"
    nil
    ""
    "3" ) )

;;;; testinput/365: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/365"
  "^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]"
  "From abcd  Mon Sep 01 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep 01 12:33"
    "abcd" ) )

;;;; testinput/368: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/368"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Mon Sep 01 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep 01 12:33"
    "Sep " ) )

;;;; testinput/369: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/369"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Mon Sep  1 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep  1 12:33"
    "Sep  " ) )

;;;; testinput/370: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/370"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Sep 01 12:33:02 1997"
  '(:single-line nil)
  nil
 )

;;;; testinput/373: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/373"
  "^12.34"
  (backslash "12\\n34")
  '(:single-line t)
  (list (backslash "12\\n34")) )

;;;; testinput/374: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/374"
  "^12.34"
  (backslash "12\\u000D34")
  '(:single-line t)
  (list (backslash "12\\u000D34")) )

;;;; testinput/377: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/377"
  "\\w+(?=\\t)"
  (backslash "the quick brown\\t fox")
  '(:single-line nil)
  (list "brown") )

;;;; testinput/380: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/380"
  "foo(?!bar)(.*)"
  "foobar is foolish see?"
  '(:single-line nil)
  (list
    "foolish see?"
    "lish see?" ) )

;;;; testinput/383: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/383"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "foobar crowbar etc"
  '(:single-line nil)
  (list
    "rowbar etc"
    " etc" ) )

;;;; testinput/384: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/384"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "barrel"
  '(:single-line nil)
  (list
    "barrel"
    "rel" ) )

;;;; testinput/385: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/385"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "2barrel"
  '(:single-line nil)
  (list
    "2barrel"
    "rel" ) )

;;;; testinput/386: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/386"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "A barrel"
  '(:single-line nil)
  (list
    "A barrel"
    "rel" ) )

;;;; testinput/389: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/389"
  "^(\\D*)(?=\\d)(?!123)"
  "abc456"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; testinput/390: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/390"
  "^(\\D*)(?=\\d)(?!123)"
  "abc123"
  '(:single-line nil)
  nil
 )

;;;; testinput/394: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/394"
  (backslash "^1234(?# test newlines\\n  inside)")
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput/398: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/398"
  (backslash "^1234 #comment in extended re\\n  ")
  "1234"
  '(:extended-syntax t :single-line nil)
  (list "1234") )

;;;; testinput/402: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/402"
  (backslash "#rhubarb\\n  abcd")
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list "abcd") )

;;;; testinput/405: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/405"
  "^abcd#rhubarb"
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list "abcd") )

;;;; testinput/408: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/408"
  "^(a)\\1{2,3}(.)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a"
    "b" ) )

;;;; testinput/409: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/409"
  "^(a)\\1{2,3}(.)"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a"
    "b" ) )

;;;; testinput/410: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/410"
  "^(a)\\1{2,3}(.)"
  "aaaaab"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "a" ) )

;;;; testinput/411: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/411"
  "^(a)\\1{2,3}(.)"
  "aaaaaab"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "a" ) )

;;;; testinput/414: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/414"
  "(?!^)abc"
  "the abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/415: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/415"
  "(?!^)abc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/418: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/418"
  "(?=^)abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/419: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/419"
  "(?=^)abc"
  "the abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/422: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/422"
  "^[ab]{1,3}(ab*|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabb"
    "b" ) )

;;;; testinput/425: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/425"
  "^[ab]{1,3}?(ab*|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabbbbb"
    "abbbbb" ) )

;;;; testinput/428: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/428"
  "^[ab]{1,3}?(ab*?|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/431: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/431"
  "^[ab]{1,3}(ab*?|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabb"
    "b" ) )

;;;; testinput/627: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/627"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "Alan Other <user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "Alan Other <user@dom.ain>") )

;;;; testinput/628: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/628"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "<user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput/629: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/629"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "user@dom.ain"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput/630: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/630"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "\"A. Other\" <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list "\"A. Other\" <user.1234@dom.ain> (a comment)") )

;;;; testinput/631: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/631"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "A. Other <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list " Other <user.1234@dom.ain> (a comment)") )

;;;; testinput/632: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/632"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"
  '(:extended-syntax t :single-line nil)
  (list "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay") )

;;;; testinput/633: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/633"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "A missing angle <user@some.where"
  '(:extended-syntax t :single-line nil)
  (list "user@some.where") )

;;;; testinput/634: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/634"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "The quick brown fox"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/1218: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1218"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "Alan Other <user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "Alan Other <user@dom.ain>") )

;;;; testinput/1219: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1219"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "<user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput/1220: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1220"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "user@dom.ain"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput/1221: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1221"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "\"A. Other\" <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list "\"A. Other\" <user.1234@dom.ain>") )

;;;; testinput/1222: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1222"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "A. Other <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list " Other <user.1234@dom.ain>") )

;;;; testinput/1223: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1223"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"
  '(:extended-syntax t :single-line nil)
  (list "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay") )

;;;; testinput/1224: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1224"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "A missing angle <user@some.where"
  '(:extended-syntax t :single-line nil)
  (list "user@some.where") )

;;;; testinput/1225: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1225"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "The quick brown fox"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/1228: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1228"
  "abc\\0def\\00pqr\\000xyz\\0000AB"
  (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")
  '(:single-line nil)
  (list (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")) )

;;;; testinput/1229: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1229"
  "abc\\0def\\00pqr\\000xyz\\0000AB"
  (backslash "abc456 abc\\u0000def\\u0000pqr\\u0000xyz\\u00000ABCDE")
  '(:single-line nil)
  (list (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")) )

;;;; testinput/1232: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1232"
  "abc\\x0def\\x00pqr\\x000xyz\\x0000AB"
  (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")
  '(:single-line nil)
  (list (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")) )

;;;; testinput/1233: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1233"
  "abc\\x0def\\x00pqr\\x000xyz\\x0000AB"
  (backslash "abc456 abc\\u000Def\\u0000pqr\\u00000xyz\\u000000ABCDE")
  '(:single-line nil)
  (list (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")) )

;;;; testinput/1236: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1236"
  "^[\\000-\\037]"
  (backslash "\\u0000A")
  '(:single-line nil)
  (list (backslash "\\u0000")) )

;;;; testinput/1237: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1237"
  "^[\\000-\\037]"
  (backslash "\\u0001B")
  '(:single-line nil)
  (list (backslash "\\u0001")) )

;;;; testinput/1238: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1238"
  "^[\\000-\\037]"
  (backslash "\\u001FC")
  '(:single-line nil)
  (list (backslash "\\u001F")) )

;;;; testinput/1241: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1241"
  "\\0*"
  (backslash "\\u0000\\u0000\\u0000\\u0000")
  '(:single-line nil)
  (list (backslash "\\u0000\\u0000\\u0000\\u0000")) )

;;;; testinput/1244: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1244"
  "A\\x00{2,3}Z"
  (backslash "The A\\u0000\\u0000Z")
  '(:single-line nil)
  (list (backslash "A\\u0000\\u0000Z")) )

;;;; testinput/1245: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1245"
  "A\\x00{2,3}Z"
  (backslash "An A\\u0000\\u0000\\u0000Z")
  '(:single-line nil)
  (list (backslash "A\\u0000\\u0000\\u0000Z")) )

;;;; testinput/1246: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1246"
  "A\\x00{2,3}Z"
  (backslash "A\\u0000Z")
  '(:single-line nil)
  nil
 )

;;;; testinput/1247: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1247"
  "A\\x00{2,3}Z"
  (backslash "A\\u0000\\u0000\\u0000\\u0000Z")
  '(:single-line nil)
  nil
 )

;;;; testinput/1250: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1250"
  "^(cow|)\\1(bell)"
  "cowcowbell"
  '(:single-line nil)
  (list
    "cowcowbell"
    "cow"
    "bell" ) )

;;;; testinput/1251: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1251"
  "^(cow|)\\1(bell)"
  "bell"
  '(:single-line nil)
  (list
    "bell"
    ""
    "bell" ) )

;;;; testinput/1252: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1252"
  "^(cow|)\\1(bell)"
  "cowbell"
  '(:single-line nil)
  nil
 )

;;;; testinput/1255: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1255"
  "^\\s"
  " abc"
  '(:single-line nil)
  (list " ") )

;;;; testinput/1256: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1256"
  "^\\s"
  (backslash "\\u000Cabc")
  '(:single-line nil)
  (list (backslash "\\u000C")) )

;;;; testinput/1257: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1257"
  "^\\s"
  (backslash "\\nabc")
  '(:single-line nil)
  (list "
") )

;;;; testinput/1258: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1258"
  "^\\s"
  (backslash "\\u000Dabc")
  '(:single-line nil)
  (list (backslash "\\u000D")) )

;;;; testinput/1259: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1259"
  "^\\s"
  (backslash "\\tabc")
  '(:single-line nil)
  (list (backslash "\\t")) )

;;;; testinput/1260: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1260"
  "^\\s"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/1264: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1264"
  (backslash "^a\\tb\\n  \\u000D  \\u000C  c")
  "abc"
  '(:extended-syntax t :single-line nil)
  (list "abc") )

;;;; testinput/1267: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1267"
  "^(a|)\\1*b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/1268: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1268"
  "^(a|)\\1*b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput/1269: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1269"
  "^(a|)\\1*b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1270: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1270"
  "^(a|)\\1*b"
  "acb"
  '(:single-line nil)
  nil
 )

;;;; testinput/1273: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1273"
  "^(a|)\\1+b"
  "aab"
  '(:single-line nil)
  (list
    "aab"
    "a" ) )

;;;; testinput/1274: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1274"
  "^(a|)\\1+b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput/1275: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1275"
  "^(a|)\\1+b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1276: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1276"
  "^(a|)\\1+b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1279: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1279"
  "^(a|)\\1?b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/1280: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1280"
  "^(a|)\\1?b"
  "aab"
  '(:single-line nil)
  (list
    "aab"
    "a" ) )

;;;; testinput/1281: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1281"
  "^(a|)\\1?b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1282: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1282"
  "^(a|)\\1?b"
  "acb"
  '(:single-line nil)
  nil
 )

;;;; testinput/1285: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1285"
  "^(a|)\\1{2}b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a" ) )

;;;; testinput/1286: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1286"
  "^(a|)\\1{2}b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1287: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1287"
  "^(a|)\\1{2}b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1288: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1288"
  "^(a|)\\1{2}b"
  "aab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1289: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1289"
  "^(a|)\\1{2}b"
  "aaaab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1292: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1292"
  "^(a|)\\1{2,3}b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a" ) )

;;;; testinput/1293: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1293"
  "^(a|)\\1{2,3}b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput/1294: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1294"
  "^(a|)\\1{2,3}b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1295: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1295"
  "^(a|)\\1{2,3}b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1296: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1296"
  "^(a|)\\1{2,3}b"
  "aab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1297: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1297"
  "^(a|)\\1{2,3}b"
  "aaaaab"
  '(:single-line nil)
  nil
 )

;;;; testinput/1300: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1300"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/1301: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1301"
  "ab{1,3}bc"
  "abbbc"
  '(:single-line nil)
  (list "abbbc") )

;;;; testinput/1302: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1302"
  "ab{1,3}bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput/1303: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1303"
  "ab{1,3}bc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/1304: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1304"
  "ab{1,3}bc"
  "abbbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/1307: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/1307"
  "([^.]*)\\.([^:]*):[T ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput/1310: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/1310"
  "([^.]*)\\.([^:]*):[T ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:ignore-case t :single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput/1313: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/1313"
  "([^.]*)\\.([^:]*):[t ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:ignore-case t :single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput/1316: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1316"
  "^[W-c]+$"
  "WXY_^abc"
  '(:single-line nil)
  (list "WXY_^abc") )

;;;; testinput/1317: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1317"
  "^[W-c]+$"
  "wxy"
  '(:single-line nil)
  nil
 )

;;;; testinput/1320: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1320"
  "^[W-c]+$"
  "WXY_^abc"
  '(:ignore-case t :single-line nil)
  (list "WXY_^abc") )

;;;; testinput/1321: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1321"
  "^[W-c]+$"
  "wxy_^ABC"
  '(:ignore-case t :single-line nil)
  (list "wxy_^ABC") )

;;;; testinput/1324: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1324"
  "^[\\x3f-\\x5F]+$"
  "WXY_^abc"
  '(:ignore-case t :single-line nil)
  (list "WXY_^abc") )

;;;; testinput/1325: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1325"
  "^[\\x3f-\\x5F]+$"
  "wxy_^ABC"
  '(:ignore-case t :single-line nil)
  (list "wxy_^ABC") )

;;;; testinput/1328: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1328"
  "^abc$"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1329: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1329"
  "^abc$"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1330: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1330"
  "^abc$"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1331: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1331"
  "^abc$"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1334: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1334"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/1335: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1335"
  "^abc$"
  (backslash "qqq\\nabc")
  '(:single-line nil)
  nil
 )

;;;; testinput/1336: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1336"
  "^abc$"
  (backslash "abc\\nzzz")
  '(:single-line nil)
  nil
 )

;;;; testinput/1337: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1337"
  "^abc$"
  (backslash "qqq\\nabc\\nzzz")
  '(:single-line nil)
  nil
 )

;;;; testinput/1340: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1340"
  "\\Aabc\\Z"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1341: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1341"
  "\\Aabc\\Z"
  "abc
"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/1342: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1342"
  "\\Aabc\\Z"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/1343: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1343"
  "\\Aabc\\Z"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/1344: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1344"
  "\\Aabc\\Z"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/1347: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1347"
  "\\A(.)*\\Z"
  (backslash "abc\\ndef")
  '(:single-line t)
  (list
    (backslash "abc\\ndef")
    "f" ) )

;;;; testinput/1350: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1350"
  "\\A(.)*\\Z"
  (backslash "abc\\ndef")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/1353: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1353"
  "(?:b)|(?::+)"
  "b::c"
  '(:single-line nil)
  (list "b") )

;;;; testinput/1354: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1354"
  "(?:b)|(?::+)"
  "c::b"
  '(:single-line nil)
  (list "::") )

;;;; testinput/1357: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1357"
  "[-az]+"
  "az-"
  '(:single-line nil)
  (list "az-") )

;;;; testinput/1358: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1358"
  "[-az]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput/1361: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1361"
  "[az-]+"
  "za-"
  '(:single-line nil)
  (list "za-") )

;;;; testinput/1362: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1362"
  "[az-]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput/1365: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1365"
  "[a\\-z]+"
  "a-z"
  '(:single-line nil)
  (list "a-z") )

;;;; testinput/1366: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1366"
  "[a\\-z]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput/1369: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1369"
  "[a-z]+"
  "abcdxyz"
  '(:single-line nil)
  (list "abcdxyz") )

;;;; testinput/1372: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1372"
  "[\\d-]+"
  "12-34"
  '(:single-line nil)
  (list "12-34") )

;;;; testinput/1373: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1373"
  "[\\d-]+"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1376: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1376"
  "[\\d-z]+"
  "12-34z"
  '(:single-line nil)
  (list "12-34z") )

;;;; testinput/1377: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1377"
  "[\\d-z]+"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1380: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1380"
  "\\x5c"
  "\\"
  '(:single-line nil)
  (list "\\") )

;;;; testinput/1383: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1383"
  "\\x20Z"
  "the Zoo"
  '(:single-line nil)
  (list " Z") )

;;;; testinput/1384: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1384"
  "\\x20Z"
  "Zulu"
  '(:single-line nil)
  nil
 )

;;;; testinput/1387: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1387"
  "(abc)\\1"
  "abcabc"
  '(:ignore-case t :single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput/1388: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1388"
  "(abc)\\1"
  "ABCabc"
  '(:ignore-case t :single-line nil)
  (list
    "ABCabc"
    "ABC" ) )

;;;; testinput/1389: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1389"
  "(abc)\\1"
  "abcABC"
  '(:ignore-case t :single-line nil)
  (list
    "abcABC"
    "abc" ) )

;;;; testinput/1392: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1392"
  "ab{3cd"
  "ab{3cd"
  '(:single-line nil)
  (list "ab{3cd") )

;;;; testinput/1395: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1395"
  "ab{3,cd"
  "ab{3,cd"
  '(:single-line nil)
  (list "ab{3,cd") )

;;;; testinput/1398: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1398"
  "ab{3,4a}cd"
  "ab{3,4a}cd"
  '(:single-line nil)
  (list "ab{3,4a}cd") )

;;;; testinput/1401: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1401"
  "{4,5a}bc"
  "{4,5a}bc"
  '(:single-line nil)
  (list "{4,5a}bc") )

;;;; testinput/1404: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1404"
  "^a.b"
  (backslash "a\\u000Db")
  '(:single-line nil)
  (list (backslash "a\\u000Db")) )

;;;; testinput/1405: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1405"
  "^a.b"
  (backslash "a\\nb")
  '(:single-line nil)
  nil
 )

;;;; testinput/1408: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1408"
  "abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/1409: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1409"
  "abc$"
  "abc
"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/1410: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1410"
  "abc$"
  (backslash "abc\\ndef")
  '(:single-line nil)
  nil
 )

;;;; testinput/1413: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1413"
  "(abc)\\123"
  "abcS"
  '(:single-line nil)
  (list
    "abcS"
    "abc" ) )

;;;; testinput/1416: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1416"
  "(abc)\\223"
  (backslash "abc\\u0093")
  '(:single-line nil)
  (list
    (backslash "abc\\u0093")
    "abc" ) )

;;;; testinput/1419: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1419"
  "(abc)\\323"
  (backslash "abc\\u00D3")
  '(:single-line nil)
  (list
    (backslash "abc\\u00D3")
    "abc" ) )

;;;; testinput/1422: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1422"
  "(abc)\\500"
  "abc@"
  '(:single-line nil)
  (list
    "abc@"
    "abc" ) )

;;;; testinput/1423: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1423"
  "(abc)\\500"
  "abc@"
  '(:single-line nil)
  (list
    "abc@"
    "abc" ) )

;;;; testinput/1426: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1426"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1427: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1427"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1428: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1428"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1429: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1429"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1430: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1430"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1431: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1431"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput/1434: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1434"
  "abc\\81"
  (backslash "abc\\u000081")
  '(:single-line nil)
  (list (backslash "abc\\u000081")) )

;;;; testinput/1435: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1435"
  "abc\\81"
  (backslash "abc\\u000081")
  '(:single-line nil)
  (list (backslash "abc\\u000081")) )

;;;; testinput/1438: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1438"
  "abc\\91"
  (backslash "abc\\u000091")
  '(:single-line nil)
  (list (backslash "abc\\u000091")) )

;;;; testinput/1439: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1439"
  "abc\\91"
  (backslash "abc\\u000091")
  '(:single-line nil)
  (list (backslash "abc\\u000091")) )

;;;; testinput/1442: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-cl/1442"
  "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\12\\123"
  "abcdefghijkllS"
  '(:single-line nil)
  (list
    "abcdefghijkllS"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "l" ) )

;;;; testinput/1445: 
;;;
;;;    Matched with 11 captures.
;
(test-case
  "pcre-cl/1445"
  "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\12\\123"
  (backslash "abcdefghijk\\nS")
  '(:single-line nil)
  (list
    (backslash "abcdefghijk\\nS")
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k" ) )

;;;; testinput/1448: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1448"
  "ab\\gdef"
  "abgdef"
  '(:single-line nil)
  (list "abgdef") )

;;;; testinput/1451: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1451"
  "a{0}bc"
  "bc"
  '(:single-line nil)
  (list "bc") )

;;;; testinput/1454: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1454"
  "(a|(bc)){0,0}?xyz"
  "xyz"
  '(:single-line nil)
  (list "xyz") )

;;;; testinput/1457: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1457"
  "abc[\\10]de"
  (backslash "abc\\u0008de")
  '(:single-line nil)
  (list (backslash "abc\\u0008de")) )

;;;; testinput/1460: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1460"
  "abc[\\1]de"
  (backslash "abc\\u0001de")
  '(:single-line nil)
  (list (backslash "abc\\u0001de")) )

;;;; testinput/1463: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1463"
  "(abc)[\\1]de"
  (backslash "abc\\u0001de")
  '(:single-line nil)
  (list
    (backslash "abc\\u0001de")
    "abc" ) )

;;;; testinput/1466: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1466"
  "a.b(?s)"
  (backslash "a\\nb")
  '(:single-line nil)
  nil
 )

;;;; testinput/1469: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/1469"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTccccd"
  '(:single-line nil)
  (list
    "baNOTcccc"
    "b"
    "a"
    "NOT"
    "cccc" ) )

;;;; testinput/1470: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/1470"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTcccd"
  '(:single-line nil)
  (list
    "baNOTccc"
    "b"
    "a"
    "NOT"
    "ccc" ) )

;;;; testinput/1471: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/1471"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTccd"
  '(:single-line nil)
  (list
    "baNOTcc"
    "b"
    "a"
    "NO"
    "Tcc" ) )

;;;; testinput/1472: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/1472"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "bacccd"
  '(:single-line nil)
  (list
    "baccc"
    "b"
    "a"
    ""
    "ccc" ) )

;;;; testinput/1473: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1473"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "anything"
  '(:single-line nil)
  nil
 )

;;;; testinput/1474: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1474"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  (backslash "b\\u0008c")
  '(:single-line nil)
  nil
 )

;;;; testinput/1475: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1475"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baccd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1478: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1478"
  "[^a]"
  "Abc"
  '(:single-line nil)
  (list "A") )

;;;; testinput/1481: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1481"
  "[^a]"
  "Abc"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput/1484: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1484"
  "[^a]+"
  "AAAaAbc"
  '(:single-line nil)
  (list "AAA") )

;;;; testinput/1487: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1487"
  "[^a]+"
  "AAAaAbc"
  '(:ignore-case t :single-line nil)
  (list "bc") )

;;;; testinput/1490: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1490"
  "[^a]+"
  (backslash "bbb\\nccc")
  '(:single-line nil)
  (list (backslash "bbb\\nccc")) )

;;;; testinput/1493: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1493"
  "[^k]$"
  "abc"
  '(:single-line nil)
  (list "c") )

;;;; testinput/1494: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1494"
  "[^k]$"
  "abk"
  '(:single-line nil)
  nil
 )

;;;; testinput/1497: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1497"
  "[^k]{2,3}$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/1498: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1498"
  "[^k]{2,3}$"
  "kbc"
  '(:single-line nil)
  (list "bc") )

;;;; testinput/1499: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1499"
  "[^k]{2,3}$"
  "kabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/1500: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1500"
  "[^k]{2,3}$"
  "abk"
  '(:single-line nil)
  nil
 )

;;;; testinput/1501: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1501"
  "[^k]{2,3}$"
  "akb"
  '(:single-line nil)
  nil
 )

;;;; testinput/1502: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1502"
  "[^k]{2,3}$"
  "akk"
  '(:single-line nil)
  nil
 )

;;;; testinput/1505: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1505"
  "^\\d{8,}@.+[^k]$"
  "12345678@a.b.c.d"
  '(:single-line nil)
  (list "12345678@a.b.c.d") )

;;;; testinput/1506: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1506"
  "^\\d{8,}@.+[^k]$"
  "123456789@x.y.z"
  '(:single-line nil)
  (list "123456789@x.y.z") )

;;;; testinput/1507: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1507"
  "^\\d{8,}@.+[^k]$"
  "12345678@x.y.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput/1508: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1508"
  "^\\d{8,}@.+[^k]$"
  "1234567@a.b.c.d"
  '(:single-line nil)
  nil
 )

;;;; testinput/1511: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1511"
  "(a)\\1{8,}"
  "aaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaa"
    "a" ) )

;;;; testinput/1512: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1512"
  "(a)\\1{8,}"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "a" ) )

;;;; testinput/1513: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1513"
  "(a)\\1{8,}"
  "aaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1516: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1516"
  "[^a]"
  "aaaabcd"
  '(:single-line nil)
  (list "b") )

;;;; testinput/1517: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1517"
  "[^a]"
  "aaAabcd"
  '(:single-line nil)
  (list "A") )

;;;; testinput/1520: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1520"
  "[^a]"
  "aaaabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput/1521: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1521"
  "[^a]"
  "aaAabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput/1524: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1524"
  "[^az]"
  "aaaabcd"
  '(:single-line nil)
  (list "b") )

;;;; testinput/1525: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1525"
  "[^az]"
  "aaAabcd"
  '(:single-line nil)
  (list "A") )

;;;; testinput/1528: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1528"
  "[^az]"
  "aaaabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput/1529: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1529"
  "[^az]"
  "aaAabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput/1532: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1532"
  "\\000\\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\\040\\041\\042\\043\\044\\045\\046\\047\\050\\051\\052\\053\\054\\055\\056\\057\\060\\061\\062\\063\\064\\065\\066\\067\\070\\071\\072\\073\\074\\075\\076\\077\\100\\101\\102\\103\\104\\105\\106\\107\\110\\111\\112\\113\\114\\115\\116\\117\\120\\121\\122\\123\\124\\125\\126\\127\\130\\131\\132\\133\\134\\135\\136\\137\\140\\141\\142\\143\\144\\145\\146\\147\\150\\151\\152\\153\\154\\155\\156\\157\\160\\161\\162\\163\\164\\165\\166\\167\\170\\171\\172\\173\\174\\175\\176\\177\\200\\201\\202\\203\\204\\205\\206\\207\\210\\211\\212\\213\\214\\215\\216\\217\\220\\221\\222\\223\\224\\225\\226\\227\\230\\231\\232\\233\\234\\235\\236\\237\\240\\241\\242\\243\\244\\245\\246\\247\\250\\251\\252\\253\\254\\255\\256\\257\\260\\261\\262\\263\\264\\265\\266\\267\\270\\271\\272\\273\\274\\275\\276\\277\\300\\301\\302\\303\\304\\305\\306\\307\\310\\311\\312\\313\\314\\315\\316\\317\\320\\321\\322\\323\\324\\325\\326\\327\\330\\331\\332\\333\\334\\335\\336\\337\\340\\341\\342\\343\\344\\345\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\\360\\361\\362\\363\\364\\365\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377"
  (backslash "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\t\\n\\u000B\\u000C\\u000D\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\u007F\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087\\u0088\\u0089\\u008A\\u008B\\u008C\\u008D\\u008E\\u008F\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097\\u0098\\u0099\\u009A\\u009B\\u009C\\u009D\\u009E\\u009F\\u00A0\\u00A1\\u00A2\\u00A3\\u00A4\\u00A5\\u00A6\\u00A7\\u00A8\\u00A9\\u00AA\\u00AB\\u00AC\\u00AD\\u00AE\\u00AF\\u00B0\\u00B1\\u00B2\\u00B3\\u00B4\\u00B5\\u00B6\\u00B7\\u00B8\\u00B9\\u00BA\\u00BB\\u00BC\\u00BD\\u00BE\\u00BF\\u00C0\\u00C1\\u00C2\\u00C3\\u00C4\\u00C5\\u00C6\\u00C7\\u00C8\\u00C9\\u00CA\\u00CB\\u00CC\\u00CD\\u00CE\\u00CF\\u00D0\\u00D1\\u00D2\\u00D3\\u00D4\\u00D5\\u00D6\\u00D7\\u00D8\\u00D9\\u00DA\\u00DB\\u00DC\\u00DD\\u00DE\\u00DF\\u00E0\\u00E1\\u00E2\\u00E3\\u00E4\\u00E5\\u00E6\\u00E7\\u00E8\\u00E9\\u00EA\\u00EB\\u00EC\\u00ED\\u00EE\\u00EF\\u00F0\\u00F1\\u00F2\\u00F3\\u00F4\\u00F5\\u00F6\\u00F7\\u00F8\\u00F9\\u00FA\\u00FB\\u00FC\\u00FD\\u00FE\\u00FF")
  '(:single-line nil)
  (list (backslash "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\t\\n\\u000B\\u000C\\u000D\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\u007F\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087\\u0088\\u0089\\u008A\\u008B\\u008C\\u008D\\u008E\\u008F\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097\\u0098\\u0099\\u009A\\u009B\\u009C\\u009D\\u009E\\u009F\\u00A0\\u00A1\\u00A2\\u00A3\\u00A4\\u00A5\\u00A6\\u00A7\\u00A8\\u00A9\\u00AA\\u00AB\\u00AC\\u00AD\\u00AE\\u00AF\\u00B0\\u00B1\\u00B2\\u00B3\\u00B4\\u00B5\\u00B6\\u00B7\\u00B8\\u00B9\\u00BA\\u00BB\\u00BC\\u00BD\\u00BE\\u00BF\\u00C0\\u00C1\\u00C2\\u00C3\\u00C4\\u00C5\\u00C6\\u00C7\\u00C8\\u00C9\\u00CA\\u00CB\\u00CC\\u00CD\\u00CE\\u00CF\\u00D0\\u00D1\\u00D2\\u00D3\\u00D4\\u00D5\\u00D6\\u00D7\\u00D8\\u00D9\\u00DA\\u00DB\\u00DC\\u00DD\\u00DE\\u00DF\\u00E0\\u00E1\\u00E2\\u00E3\\u00E4\\u00E5\\u00E6\\u00E7\\u00E8\\u00E9\\u00EA\\u00EB\\u00EC\\u00ED\\u00EE\\u00EF\\u00F0\\u00F1\\u00F2\\u00F3\\u00F4\\u00F5\\u00F6\\u00F7\\u00F8\\u00F9\\u00FA\\u00FB\\u00FC\\u00FD\\u00FE\\u00FF")) )

;;;; testinput/1535: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1535"
  "P[^*]TAIRE[^*]{1,6}?LL"
  "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"
  '(:single-line nil)
  (list "PSTAIREISLL") )

;;;; testinput/1538: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1538"
  "P[^*]TAIRE[^*]{1,}?LL"
  "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"
  '(:single-line nil)
  (list "PSTAIREISLL") )

;;;; testinput/1541: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1541"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.230003938"
  '(:single-line nil)
  (list
    ".230003938"
    ".23" ) )

;;;; testinput/1542: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1542"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875000282"
    ".875" ) )

;;;; testinput/1543: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1543"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.235"
  '(:single-line nil)
  (list
    ".235"
    ".23" ) )

;;;; testinput/1546: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1546"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.230003938"
  '(:single-line nil)
  (list
    ".23"
    ".23"
    "" ) )

;;;; testinput/1547: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1547"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875"
    ".875"
    "5" ) )

;;;; testinput/1548: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1548"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.235"
  '(:single-line nil)
  nil
 )

;;;; testinput/1551: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1551"
  "a(?)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/1554: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1554"
  "\\b(foo)\\s+(\\w+)"
  "Food is on the foo table"
  '(:ignore-case t :single-line nil)
  (list
    "foo table"
    "foo"
    "table" ) )

;;;; testinput/1557: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1557"
  "foo(.*)bar"
  "The food is under the bar in the barn."
  '(:single-line nil)
  (list
    "food is under the bar in the bar"
    "d is under the bar in the " ) )

;;;; testinput/1560: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1560"
  "foo(.*?)bar"
  "The food is under the bar in the barn."
  '(:single-line nil)
  (list
    "food is under the bar"
    "d is under the " ) )

;;;; testinput/1563: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1563"
  "(.*)(\\d*)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 53147"
    "" ) )

;;;; testinput/1566: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1566"
  "(.*)(\\d+)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 5314"
    "7" ) )

;;;; testinput/1569: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1569"
  "(.*?)(\\d*)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    ""
    ""
    "" ) )

;;;; testinput/1572: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1572"
  "(.*?)(\\d+)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2"
    "I have "
    "2" ) )

;;;; testinput/1575: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1575"
  "(.*)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 5314"
    "7" ) )

;;;; testinput/1578: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1578"
  "(.*?)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput/1581: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1581"
  "(.*)\\b(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput/1584: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1584"
  "(.*\\D)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput/1587: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1587"
  "^\\D*(?!123)"
  "ABC123"
  '(:single-line nil)
  (list "AB") )

;;;; testinput/1590: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1590"
  "^(\\D*)(?=\\d)(?!123)"
  "ABC445"
  '(:single-line nil)
  (list
    "ABC"
    "ABC" ) )

;;;; testinput/1591: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1591"
  "^(\\D*)(?=\\d)(?!123)"
  "ABC123"
  '(:single-line nil)
  nil
 )

;;;; testinput/1594: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1594"
  "^[W-]46]"
  "W46]789"
  '(:single-line nil)
  (list "W46]") )

;;;; testinput/1595: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1595"
  "^[W-]46]"
  "-46]789"
  '(:single-line nil)
  (list "-46]") )

;;;; testinput/1596: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1596"
  "^[W-]46]"
  "Wall"
  '(:single-line nil)
  nil
 )

;;;; testinput/1597: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1597"
  "^[W-]46]"
  "Zebra"
  '(:single-line nil)
  nil
 )

;;;; testinput/1598: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1598"
  "^[W-]46]"
  "42"
  '(:single-line nil)
  nil
 )

;;;; testinput/1599: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1599"
  "^[W-]46]"
  "[abcd]"
  '(:single-line nil)
  nil
 )

;;;; testinput/1600: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1600"
  "^[W-]46]"
  "]abcd["
  '(:single-line nil)
  nil
 )

;;;; testinput/1603: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1603"
  "^[W-\\]46]"
  "W46]789"
  '(:single-line nil)
  (list "W") )

;;;; testinput/1604: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1604"
  "^[W-\\]46]"
  "Wall"
  '(:single-line nil)
  (list "W") )

;;;; testinput/1605: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1605"
  "^[W-\\]46]"
  "Zebra"
  '(:single-line nil)
  (list "Z") )

;;;; testinput/1606: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1606"
  "^[W-\\]46]"
  "Xylophone"
  '(:single-line nil)
  (list "X") )

;;;; testinput/1607: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1607"
  "^[W-\\]46]"
  "42"
  '(:single-line nil)
  (list "4") )

;;;; testinput/1608: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1608"
  "^[W-\\]46]"
  "[abcd]"
  '(:single-line nil)
  (list "[") )

;;;; testinput/1609: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1609"
  "^[W-\\]46]"
  "]abcd["
  '(:single-line nil)
  (list "]") )

;;;; testinput/1610: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1610"
  "^[W-\\]46]"
  "\\backslash"
  '(:single-line nil)
  (list "\\") )

;;;; testinput/1611: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1611"
  "^[W-\\]46]"
  "-46]789"
  '(:single-line nil)
  nil
 )

;;;; testinput/1612: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1612"
  "^[W-\\]46]"
  "well"
  '(:single-line nil)
  nil
 )

;;;; testinput/1615: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1615"
  "\\d\\d/\\d\\d/\\d\\d\\d\\d"
  "01/01/2000"
  '(:single-line nil)
  (list "01/01/2000") )

;;;; testinput/1618: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1618"
  "word (?:[a-zA-Z0-9]+ ){0,10}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark otherword"
  '(:single-line nil)
  (list "word cat dog elephant mussel cow horse canary baboon snake shark otherword") )

;;;; testinput/1619: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1619"
  "word (?:[a-zA-Z0-9]+ ){0,10}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark"
  '(:single-line nil)
  nil
 )

;;;; testinput/1622: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1622"
  "word (?:[a-zA-Z0-9]+ ){0,300}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope"
  '(:single-line nil)
  nil
 )

;;;; testinput/1625: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1625"
  "^(a){0,0}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1626: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1626"
  "^(a){0,0}"
  "abc"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1627: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1627"
  "^(a){0,0}"
  "aab"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1630: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1630"
  "^(a){0,1}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1631: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1631"
  "^(a){0,1}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1632: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1632"
  "^(a){0,1}"
  "aab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1635: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1635"
  "^(a){0,2}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1636: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1636"
  "^(a){0,2}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1637: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1637"
  "^(a){0,2}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1640: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1640"
  "^(a){0,3}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1641: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1641"
  "^(a){0,3}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1642: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1642"
  "^(a){0,3}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1643: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1643"
  "^(a){0,3}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput/1646: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1646"
  "^(a){0,}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput/1647: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1647"
  "^(a){0,}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1648: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1648"
  "^(a){0,}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1649: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1649"
  "^(a){0,}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput/1650: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1650"
  "^(a){0,}"
  "aaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "a" ) )

;;;; testinput/1653: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1653"
  "^(a){1,1}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1654: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1654"
  "^(a){1,1}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1655: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1655"
  "^(a){1,1}"
  "aab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1658: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1658"
  "^(a){1,2}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1659: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1659"
  "^(a){1,2}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1660: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1660"
  "^(a){1,2}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1663: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1663"
  "^(a){1,3}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1664: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1664"
  "^(a){1,3}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1665: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1665"
  "^(a){1,3}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1666: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1666"
  "^(a){1,3}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput/1669: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1669"
  "^(a){1,}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1670: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1670"
  "^(a){1,}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/1671: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1671"
  "^(a){1,}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/1672: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1672"
  "^(a){1,}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput/1673: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1673"
  "^(a){1,}"
  "aaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "a" ) )

;;;; testinput/1676: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1676"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "bib.gif") )

;;;; testinput/1679: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1679"
  ".{0,}\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "bib.gif") )

;;;; testinput/1682: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1682"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line nil)
  (list "bib.gif") )

;;;; testinput/1685: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1685"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif")) )

;;;; testinput/1688: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1688"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif")) )

;;;; testinput/1691: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1691"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "no") )

;;;; testinput/1694: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1694"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line nil)
  (list "borfle") )

;;;; testinput/1697: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1697"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif\\nno")) )

;;;; testinput/1700: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1700"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif\\nno")) )

;;;; testinput/1703: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1703"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:single-line nil)
  (list "no") )

;;;; testinput/1706: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1706"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:multiple-lines t :single-line nil)
  (list "borfle") )

;;;; testinput/1709: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1709"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif\\nno\\n")) )

;;;; testinput/1712: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1712"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif\\nno\\n")) )

;;;; testinput/1715: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1715"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list
    "1234X"
    "1234X" ) )

;;;; testinput/1716: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1716"
  "(.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput/1717: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1717"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput/1720: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1720"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:multiple-lines t :single-line nil)
  (list
    "1234X"
    "1234X" ) )

;;;; testinput/1721: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1721"
  "(.*X|^B)"
  "BarFoo"
  '(:multiple-lines t :single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput/1722: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1722"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:multiple-lines t :single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput/1725: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1725"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line t)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput/1726: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1726"
  "(.*X|^B)"
  "BarFoo"
  '(:single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput/1727: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1727"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line t)
  nil
 )

;;;; testinput/1730: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1730"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:multiple-lines t :single-line t)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput/1731: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1731"
  "(.*X|^B)"
  "BarFoo"
  '(:multiple-lines t :single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput/1732: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1732"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:multiple-lines t :single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput/1735: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1735"
  "(?s)(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput/1736: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1736"
  "(?s)(.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput/1737: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1737"
  "(?s)(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput/1740: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1740"
  "(?s:.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list (backslash "abcde\\n1234X")) )

;;;; testinput/1741: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1741"
  "(?s:.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list "B") )

;;;; testinput/1742: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1742"
  "(?s:.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput/1745: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1745"
  "^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  nil
 )

;;;; testinput/1748: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1748"
  "(?s)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list (backslash "abc\\nB")) )

;;;; testinput/1751: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1751"
  "(?m)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list "B") )

;;;; testinput/1754: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1754"
  "(?ms)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list (backslash "abc\\nB")) )

;;;; testinput/1757: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1757"
  "(?ms)^B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list "B") )

;;;; testinput/1760: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1760"
  "(?s)B$"
  "B
"
  '(:single-line nil)
  (list "B") )

;;;; testinput/1763: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1763"
  "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput/1766: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1766"
  "^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput/1769: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1769"
  "^[\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d]"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput/1772: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1772"
  "^[abc]{12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list "abcabcabcabc") )

;;;; testinput/1775: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1775"
  "^[a-c]{12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list "abcabcabcabc") )

;;;; testinput/1778: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1778"
  "^(a|b|c){12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list
    "abcabcabcabc"
    "c" ) )

;;;; testinput/1781: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1781"
  "^[abcdefghijklmnopqrstuvwxy0123456789]"
  "n"
  '(:single-line nil)
  (list "n") )

;;;; testinput/1782: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1782"
  "^[abcdefghijklmnopqrstuvwxy0123456789]"
  "z"
  '(:single-line nil)
  nil
 )

;;;; testinput/1785: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1785"
  "abcde{0,0}"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput/1786: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1786"
  "abcde{0,0}"
  "abce"
  '(:single-line nil)
  nil
 )

;;;; testinput/1789: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1789"
  "ab[cd]{0,0}e"
  "abe"
  '(:single-line nil)
  (list "abe") )

;;;; testinput/1790: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1790"
  "ab[cd]{0,0}e"
  "abcde"
  '(:single-line nil)
  nil
 )

;;;; testinput/1793: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1793"
  "ab(c){0,0}d"
  "abd"
  '(:single-line nil)
  (list
    "abd"
    nil ) )

;;;; testinput/1794: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1794"
  "ab(c){0,0}d"
  "abcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/1797: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1797"
  "a(b*)"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/1798: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1798"
  "a(b*)"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/1799: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1799"
  "a(b*)"
  "abbbb"
  '(:single-line nil)
  (list
    "abbbb"
    "bbbb" ) )

;;;; testinput/1800: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1800"
  "a(b*)"
  "bbbbb"
  '(:single-line nil)
  nil
 )

;;;; testinput/1803: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1803"
  "ab\\d{0}e"
  "abe"
  '(:single-line nil)
  (list "abe") )

;;;; testinput/1804: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1804"
  "ab\\d{0}e"
  "ab1e"
  '(:single-line nil)
  nil
 )

;;;; testinput/1807: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1807"
  "\"([^\\\\\"]+|\\\\.)*\""
  "the \"quick\" brown fox"
  '(:single-line nil)
  (list
    "\"quick\""
    "quick" ) )

;;;; testinput/1808: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1808"
  "\"([^\\\\\"]+|\\\\.)*\""
  "\"the \\\"quick\\\" brown fox\""
  '(:single-line nil)
  (list
    "\"the \\\"quick\\\" brown fox\""
    " brown fox" ) )

;;;; testinput/1811: 
;;;
;;;    
;
(test-case/g
  "pcre-cl/1811"
  ".*?"
  "abc"
  '(:single-line nil)
  (list ""
        "a"
        ""
        "b"
        ""
        "c"
        "" )
    "" )

;;;; testinput/1814: 
;;;
;;;    
;
(test-case/g
  "pcre-cl/1814"
  "\\b"
  "abc"
  '(:single-line nil)
  (list ""
        "" )
    "" )

;;;; testinput/1817: 
;;;
;;;    
;
(test-case/g
  "pcre-cl/1817"
  "\\b"
  "abc"
  '(:single-line nil)
  (list ""
        "" )
    "" )

;;;; testinput/1820: 
;;;
;;;    
;
(test-case/g
  "pcre-cl/1820"
  "(?#)"
  "abc"
  '(:single-line nil)
  (list ""
        ""
        ""
        "" )
    "" )

;;;; testinput/1823: 
;;;
;;;    Matched with 11 captures.
;
(test-case
  "pcre-cl/1823"
  "<tr([\\w\\W\\s\\d][^<>]{0,})><TD([\\w\\W\\s\\d][^<>]{0,})>([\\d]{0,}\\.)(.*)((<BR>([\\w\\W\\s\\d][^<>]{0,})|[\\s]{0,}))</a></TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})</TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})</TD></TR>"
  "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>"
  '(:ignore-case t :single-line t)
  (list
    "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>"
    " BGCOLOR='#DBE9E9'"
    " align=left valign=top"
    "43."
    "<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)"
    ""
    ""
    nil
    " align=left valign=top"
    "Lega lstaff.com"
    " align=left valign=top"
    "CA - Statewide" ) )

;;;; testinput/1826: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1826"
  "a[^a]b"
  "acb"
  '(:single-line nil)
  (list "acb") )

;;;; testinput/1827: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1827"
  "a[^a]b"
  (backslash "a\\nb")
  '(:single-line nil)
  (list (backslash "a\\nb")) )

;;;; testinput/1830: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1830"
  "a.b"
  "acb"
  '(:single-line nil)
  (list "acb") )

;;;; testinput/1831: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1831"
  "a.b"
  (backslash "a\\nb")
  '(:single-line nil)
  nil
 )

;;;; testinput/1834: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1834"
  "a[^a]b"
  "acb"
  '(:single-line t)
  (list "acb") )

;;;; testinput/1835: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1835"
  "a[^a]b"
  (backslash "a\\nb")
  '(:single-line t)
  (list (backslash "a\\nb")) )

;;;; testinput/1838: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1838"
  "a.b"
  "acb"
  '(:single-line t)
  (list "acb") )

;;;; testinput/1839: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1839"
  "a.b"
  (backslash "a\\nb")
  '(:single-line t)
  (list (backslash "a\\nb")) )

;;;; testinput/1842: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1842"
  "^(b+?|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput/1843: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1843"
  "^(b+?|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput/1844: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1844"
  "^(b+?|a){1,2}?c"
  "bbbac"
  '(:single-line nil)
  (list
    "bbbac"
    "a" ) )

;;;; testinput/1845: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1845"
  "^(b+?|a){1,2}?c"
  "bbbbac"
  '(:single-line nil)
  (list
    "bbbbac"
    "a" ) )

;;;; testinput/1846: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1846"
  "^(b+?|a){1,2}?c"
  "bbbbbac"
  '(:single-line nil)
  (list
    "bbbbbac"
    "a" ) )

;;;; testinput/1849: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1849"
  "^(b+|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput/1850: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1850"
  "^(b+|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput/1851: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1851"
  "^(b+|a){1,2}?c"
  "bbbac"
  '(:single-line nil)
  (list
    "bbbac"
    "a" ) )

;;;; testinput/1852: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1852"
  "^(b+|a){1,2}?c"
  "bbbbac"
  '(:single-line nil)
  (list
    "bbbbac"
    "a" ) )

;;;; testinput/1853: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1853"
  "^(b+|a){1,2}?c"
  "bbbbbac"
  '(:single-line nil)
  (list
    "bbbbbac"
    "a" ) )

;;;; testinput/1856: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1856"
  "(?!\\A)x"
  (backslash "x\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/1857: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1857"
  "(?!\\A)x"
  (backslash "a\\u0008x\\n")
  '(:multiple-lines t :single-line nil)
  (list "x") )

;;;; testinput/1860: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1860"
  "\\x00{ab}"
  (backslash "\\u0000{ab}")
  '(:single-line nil)
  (list (backslash "\\u0000{ab}")) )

;;;; testinput/1863: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1863"
  "(A|B)*?CD"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil ) )

;;;; testinput/1866: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1866"
  "(A|B)*CD"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil ) )

;;;; testinput/1869: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1869"
  "(AB)*?\\1"
  "ABABAB"
  '(:single-line nil)
  (list
    "ABAB"
    "AB" ) )

;;;; testinput/1872: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1872"
  "(AB)*\\1"
  "ABABAB"
  '(:single-line nil)
  (list
    "ABABAB"
    "AB" ) )

;;;; testinput/1875: 
;;;
;;;    
;
(test-case
  "pcre-cl/1875"
  "("
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/1878: 
;;;
;;;    
;
(test-case
  "pcre-cl/1878"
  "(x)\\2"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/1881: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1881"
  "((a{0,5}){0,5}){0,5}[c]"
  "aaaaaaaaaac"
  '(:single-line nil)
  (list
    "aaaaaaaaaac"
    ""
    "" ) )

;;;; testinput/1882: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1882"
  "((a{0,5}){0,5}){0,5}[c]"
  "aaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1885: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1885"
  "((a{0,5}){0,5})*[c]"
  "aaaaaaaaaac"
  '(:single-line nil)
  (list
    "aaaaaaaaaac"
    ""
    "" ) )

;;;; testinput/1886: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1886"
  "((a{0,5}){0,5})*[c]"
  "aaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1889: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1889"
  "(\\b)*a"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/1892: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1892"
  "(a)*b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/1895: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1895"
  "(a|)*b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "" ) )

;;;; testinput/1896: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1896"
  "(a|)*b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/1897: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1897"
  "(a|)*b"
  "x"
  '(:single-line nil)
  nil
 )

;;;; testinput/1900: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1900"
  "^(?:(a)|(b))*\\1\\2$"
  "abab"
  '(:single-line nil)
  (list
    "abab"
    "a"
    "b" ) )

;;;; testinput/1903: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1903"
  "abc[^x]def"
  "abcxabcydef"
  '(:single-line nil)
  (list "abcydef") )

;;;; testinput/1906: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1906"
  "^(a|\\1x)*$"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "ax" ) )

;;;; testinput/1907: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1907"
  "^(a|\\1x)*$"
  "aaxa"
  '(:single-line nil)
  (list
    "aaxa"
    "a" ) )

;;;; testinput/1910: 
;;;

;;;; testinput/1913: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1913"
  "^(?:(a)|(b))*$"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a"
    "b" ) )

;;;; testinput/1916: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1916"
  "[\\0]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/1917: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1917"
  "[\\0]"
  (backslash "\\u0000")
  '(:single-line nil)
  (list (backslash "\\u0000")) )

;;;; testinput/1920: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1920"
  "[\\1]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/1921: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1921"
  "[\\1]"
  (backslash "\\u0001")
  '(:single-line nil)
  (list (backslash "\\u0001")) )

;;;; testinput/1924: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1924"
  "\\10()()()()()()()()()"
  "doesn't matter"
  '(:single-line nil)
  nil
 )

;;;; testinput/1927: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1927"
  "\\10()()()()()()()()()()"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/1930: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1930"
  "a(?<)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/1933: 
;;;
;;;    
;
(test-case
  "pcre-cl/1933"
  "[]"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/1936: 
;;;
;;;    
;
(test-case
  "pcre-cl/1936"
  "[\\]"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/1939: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1939"
  "()"
  "a"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/1942: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1942"
  "[\\x]"
  "x"
  '(:single-line nil)
  nil
 )

;;;; testinput/1943: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1943"
  "[\\x]"
  (backslash "\\u0000")
  '(:single-line nil)
  (list (backslash "\\u0000")) )

;;;; testinput/1946: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/1946"
  "((a)*)*"
  "a"
  '(:single-line nil)
  (list
    "a"
    ""
    nil ) )

;;;; testinput/1949: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/1949"
  "()a\\1"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/1952: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1952"
  "a\\1()"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/1955: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1955"
  "a(?i)a(?-i)a"
  "aaa"
  '(:single-line nil)
  (list "aaa") )

;;;; testinput/1956: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1956"
  "a(?i)a(?-i)a"
  "aAa"
  '(:single-line nil)
  (list "aAa") )

;;;; testinput/1957: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1957"
  "a(?i)a(?-i)a"
  "aAA"
  '(:single-line nil)
  nil
 )

;;;; testinput/1960: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1960"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "aaaaa"
  '(:single-line nil)
  (list "aaaaa") )

;;;; testinput/1961: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1961"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "aAaAa"
  '(:single-line nil)
  (list "aAaAa") )

;;;; testinput/1962: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1962"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "AaAaA"
  '(:single-line nil)
  nil
 )

;;;; testinput/1963: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1963"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "aAAAa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1964: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1964"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "AaaaA"
  '(:single-line nil)
  nil
 )

;;;; testinput/1965: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1965"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "AAAAA"
  '(:single-line nil)
  nil
 )

;;;; testinput/1966: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1966"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "aaAAA"
  '(:single-line nil)
  nil
 )

;;;; testinput/1967: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1967"
  "a(?i)a(?-i)a(?i)a(?-i)a"
  "AAaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/1970: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1970"
  "\\x"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/1971: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1971"
  "\\x"
  "X"
  '(:single-line nil)
  nil
 )

;;;; testinput/1972: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1972"
  "\\x"
  (backslash "\\u0000")
  '(:single-line nil)
  (list (backslash "\\u0000")) )

;;;; testinput/1975: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1975"
  "[a-c-e]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/1976: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1976"
  "[a-c-e]"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/1977: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1977"
  "[a-c-e]"
  "d"
  '(:single-line nil)
  nil
 )

;;;; testinput/1978: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1978"
  "[a-c-e]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/1981: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1981"
  "[b-\\d]"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/1982: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1982"
  "[b-\\d]"
  "c"
  '(:single-line nil)
  nil
 )

;;;; testinput/1983: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1983"
  "[b-\\d]"
  "d"
  '(:single-line nil)
  nil
 )

;;;; testinput/1984: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1984"
  "[b-\\d]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/1985: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1985"
  "[b-\\d]"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput/1988: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1988"
  "[\\d-f]"
  "d"
  '(:single-line nil)
  nil
 )

;;;; testinput/1989: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1989"
  "[\\d-f]"
  "e"
  '(:single-line nil)
  nil
 )

;;;; testinput/1990: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1990"
  "[\\d-f]"
  "f"
  '(:single-line nil)
  (list "f") )

;;;; testinput/1991: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1991"
  "[\\d-f]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/1992: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1992"
  "[\\d-f]"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput/1995: 
;;;
;;;    
;
(test-case
  "pcre-cl/1995"
  "["
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/1998: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/1998"
  "]"
  "]"
  '(:single-line nil)
  (list "]") )

;;;; testinput/1999: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/1999"
  "]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2002: 
;;;
;;;    
;
(test-case
  "pcre-cl/2002"
  "[]"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/2005: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2005"
  "[-a-c]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2006: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2006"
  "[-a-c]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2007: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2007"
  "[-a-c]"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/2008: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2008"
  "[-a-c]"
  "d"
  '(:single-line nil)
  nil
 )

;;;; testinput/2011: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2011"
  "[a-c-]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2012: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2012"
  "[a-c-]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2013: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2013"
  "[a-c-]"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/2014: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2014"
  "[a-c-]"
  "d"
  '(:single-line nil)
  nil
 )

;;;; testinput/2017: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2017"
  "[-]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2018: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2018"
  "[-]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2021: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2021"
  "[--]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2022: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2022"
  "[--]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2025: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2025"
  "[---]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2026: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2026"
  "[---]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2029: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2029"
  "[--b]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2030: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2030"
  "[--b]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2031: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2031"
  "[--b]"
  "c"
  '(:single-line nil)
  nil
 )

;;;; testinput/2034: 
;;;
;;;    
;
(test-case
  "pcre-cl/2034"
  "[b--]"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/2037: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2037"
  "a{"
  "a{"
  '(:single-line nil)
  (list "a{") )

;;;; testinput/2040: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2040"
  "a{}"
  "a{}"
  '(:single-line nil)
  (list "a{}") )

;;;; testinput/2043: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2043"
  "a{3"
  "a{3"
  '(:single-line nil)
  (list "a{3") )

;;;; testinput/2046: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2046"
  "a{3,"
  "a{3,"
  '(:single-line nil)
  (list "a{3,") )

;;;; testinput/2049: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2049"
  "a{3, 3}"
  "a{3,3}"
  '(:single-line nil)
  nil
 )

;;;; testinput/2050: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2050"
  "a{3, 3}"
  "a{3, 3}"
  '(:single-line nil)
  (list "a{3, 3}") )

;;;; testinput/2051: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2051"
  "a{3, 3}"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2054: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2054"
  "a{3, 3}"
  "a{3,3}"
  '(:extended-syntax t :single-line nil)
  (list "a{3,3}") )

;;;; testinput/2055: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2055"
  "a{3, 3}"
  "a{3, 3}"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2056: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2056"
  "a{3, 3}"
  "aaa"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2059: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2059"
  "a{3, }"
  "a{3,}"
  '(:single-line nil)
  nil
 )

;;;; testinput/2060: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2060"
  "a{3, }"
  "a{3, }"
  '(:single-line nil)
  (list "a{3, }") )

;;;; testinput/2061: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2061"
  "a{3, }"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2064: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2064"
  "a{3, }"
  "a{3,}"
  '(:extended-syntax t :single-line nil)
  (list "a{3,}") )

;;;; testinput/2065: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2065"
  "a{3, }"
  "a{3, }"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2066: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2066"
  "a{3, }"
  "aaa"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2069: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2069"
  "\\x x"
  (backslash "\\u0000 x")
  '(:single-line nil)
  (list (backslash "\\u0000 x")) )

;;;; testinput/2070: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2070"
  "\\x x"
  (backslash "\\u0000x")
  '(:single-line nil)
  nil
 )

;;;; testinput/2073: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2073"
  "\\x x"
  (backslash "\\u0000 x")
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2074: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2074"
  "\\x x"
  (backslash "\\u0000x")
  '(:extended-syntax t :single-line nil)
  (list (backslash "\\u0000x")) )

;;;; testinput/2077: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2077"
  "\\x 3"
  (backslash "\\u00003")
  '(:single-line nil)
  nil
 )

;;;; testinput/2078: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2078"
  "\\x 3"
  (backslash "\\u0000 3")
  '(:single-line nil)
  (list (backslash "\\u0000 3")) )

;;;; testinput/2079: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2079"
  "\\x 3"
  "x3"
  '(:single-line nil)
  nil
 )

;;;; testinput/2080: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2080"
  "\\x 3"
  "x 3"
  '(:single-line nil)
  nil
 )

;;;; testinput/2083: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2083"
  "\\x 3"
  (backslash "\\u00003")
  '(:extended-syntax t :single-line nil)
  (list (backslash "\\u00003")) )

;;;; testinput/2084: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2084"
  "\\x 3"
  (backslash "\\u0000 3")
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2085: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2085"
  "\\x 3"
  "x3"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2086: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2086"
  "\\x 3"
  "x 3"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2089: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2089"
  "^a{ 1}$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2090: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2090"
  "^a{ 1}$"
  "a{ 1}"
  '(:single-line nil)
  (list "a{ 1}") )

;;;; testinput/2091: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2091"
  "^a{ 1}$"
  "a{1}"
  '(:single-line nil)
  nil
 )

;;;; testinput/2094: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2094"
  "^a{ 1}$"
  "a"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2095: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2095"
  "^a{ 1}$"
  "a{ 1}"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2096: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2096"
  "^a{ 1}$"
  "a{1}"
  '(:extended-syntax t :single-line nil)
  (list "a{1}") )

;;;; testinput/2099: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2099"
  "{}"
  "{}"
  '(:single-line nil)
  (list "{}") )

;;;; testinput/2100: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2100"
  "{}"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2103: 
;;;
;;;    
;
(test-case
  "pcre-cl/2103"
  "{1}"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/2106: 
;;;
;;;    
;
(test-case
  "pcre-cl/2106"
  "*"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/2109: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2109"
  "|"
  "x"
  '(:single-line nil)
  (list "") )

;;;; testinput/2112: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2112"
  "\\0000"
  (backslash "\\u00000")
  '(:single-line nil)
  (list (backslash "\\u00000")) )

;;;; testinput/2115: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2115"
  "a(?<)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2118: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2118"
  "a(?i)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2119: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2119"
  "a(?i)b"
  "aB"
  '(:single-line nil)
  (list "aB") )

;;;; testinput/2120: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2120"
  "a(?i)b"
  "Ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/2123: 
;;;
;;;    
;
(test-case
  "pcre-cl/2123"
  "a(?i=a)"
  "doesn't matter"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput/2126: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2126"
  "a(?<=a){3000}a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2127: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2127"
  "a(?<=a){3000}a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2128"
  "a(?<=a){3000}a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2131: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2131"
  "a(?!=a){3000}a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2132: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2132"
  "a(?!=a){3000}a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2133: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2133"
  "a(?!=a){3000}a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2136: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2136"
  "a(){3000}a"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "" ) )

;;;; testinput/2137: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2137"
  "a(){3000}a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2138: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2138"
  "a(){3000}a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2141: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2141"
  "a(?:){3000}a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2142: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2142"
  "a(?:){3000}a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2145: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2145"
  "a(?<=a)*a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2146: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2146"
  "a(?<=a)*a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2147: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2147"
  "a(?<=a)*a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2150: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2150"
  "a(?!=a)*a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2151: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2151"
  "a(?!=a)*a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2152: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2152"
  "a(?!=a)*a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2155: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2155"
  "a()*a"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "" ) )

;;;; testinput/2156: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2156"
  "a()*a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2157: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2157"
  "a()*a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2160: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2160"
  "a(?:)*a"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2161: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2161"
  "a(?:)*a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2162: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2162"
  "a(?:)*a"
  "xa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2165: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2165"
  "x(?<=a)*a"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2166: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2166"
  "x(?<=a)*a"
  "xa"
  '(:single-line nil)
  (list "xa") )

;;;; testinput/2167: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2167"
  "x(?<=a)*a"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/2170: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2170"
  "a(?<=(a))*\\1"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/2173: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2173"
  "a(?<=(a))*?\\1"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/2176: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2176"
  "(?=(a)\\1)*aa"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/2179: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2179"
  "^((a|b){2,5}){2}$"
  "aaaaabbbbb"
  '(:single-line nil)
  (list
    "aaaaabbbbb"
    "bbbbb"
    "b" ) )

;;;; testinput/2182: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2182"
  "^(b*|ba){1,2}bc"
  "babc"
  '(:single-line nil)
  (list
    "babc"
    "" ) )

;;;; testinput/2183: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2183"
  "^(b*|ba){1,2}bc"
  "bbabc"
  '(:single-line nil)
  (list
    "bbabc"
    "ba" ) )

;;;; testinput/2184: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2184"
  "^(b*|ba){1,2}bc"
  "bababc"
  '(:single-line nil)
  (list
    "bababc"
    "ba" ) )

;;;; testinput/2185: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2185"
  "^(b*|ba){1,2}bc"
  "bababbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2186: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2186"
  "^(b*|ba){1,2}bc"
  "babababc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2189: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2189"
  "^a{4,5}(?:c|a)c$"
  "aaaaac"
  '(:single-line nil)
  (list "aaaaac") )

;;;; testinput/2190: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2190"
  "^a{4,5}(?:c|a)c$"
  "aaaaaac"
  '(:single-line nil)
  (list "aaaaaac") )

;;;; testinput/2193: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2193"
  "^(a|){4,5}(?:c|a)c$"
  "aaaaac"
  '(:single-line nil)
  (list
    "aaaaac"
    "" ) )

;;;; testinput/2194: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2194"
  "^(a|){4,5}(?:c|a)c$"
  "aaaaaac"
  '(:single-line nil)
  (list
    "aaaaaac"
    "a" ) )

;;;; testinput/2197: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2197"
  "(?m:^).abc$"
  "eeexabc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2198: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2198"
  "(?m:^).abc$"
  (backslash "eee\\nxabc")
  '(:single-line nil)
  (list "xabc") )

;;;; testinput/2201: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2201"
  "(?m:^)abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2202: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2202"
  "(?m:^)abc"
  (backslash "\\nabc")
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2206: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2206"
  "^abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2207: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2207"
  "^abc"
  (backslash "\\nabc")
  '(:single-line nil)
  nil
 )

;;;; testinput/2210: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2210"
  "\\Aabc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2211: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2211"
  "\\Aabc"
  (backslash "\\nabc")
  '(:single-line nil)
  nil
 )

;;;; testinput/2214: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2214"
  "(?<!bar)foo"
  "foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/2215: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2215"
  "(?<!bar)foo"
  "catfood"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/2216: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2216"
  "(?<!bar)foo"
  "arfootle"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/2217: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2217"
  "(?<!bar)foo"
  "rfoosh"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/2218: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2218"
  "(?<!bar)foo"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2219: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2219"
  "(?<!bar)foo"
  "towbarfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2222: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2222"
  "\\w{3}(?<!bar)foo"
  "catfood"
  '(:single-line nil)
  (list "catfoo") )

;;;; testinput/2223: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2223"
  "\\w{3}(?<!bar)foo"
  "foo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2224: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2224"
  "\\w{3}(?<!bar)foo"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2225: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2225"
  "\\w{3}(?<!bar)foo"
  "towbarfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2228: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2228"
  "(?<=(foo)a)bar"
  "fooabar"
  '(:single-line nil)
  (list
    "bar"
    "foo" ) )

;;;; testinput/2229: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2229"
  "(?<=(foo)a)bar"
  "bar"
  '(:single-line nil)
  nil
 )

;;;; testinput/2230: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2230"
  "(?<=(foo)a)bar"
  "foobbar"
  '(:single-line nil)
  nil
 )

;;;; testinput/2233: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2233"
  "\\Aabc\\z"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput/2234: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2234"
  "\\Aabc\\z"
  "abc
"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2235: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2235"
  "\\Aabc\\z"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2236: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2236"
  "\\Aabc\\z"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2237: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2237"
  "\\Aabc\\z"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2240: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2240"
  "(?>.*/)foo"
  "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/"
  '(:single-line nil)
  nil
 )

;;;; testinput/2243: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2243"
  "(?>.*/)foo"
  "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo"
  '(:single-line nil)
  (list "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo") )

;;;; testinput/2246: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2246"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.230003938"
  '(:single-line nil)
  (list
    ".230003938"
    ".23" ) )

;;;; testinput/2247: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2247"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875000282"
    ".875" ) )

;;;; testinput/2248: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2248"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.235"
  '(:single-line nil)
  nil
 )

;;;; testinput/2251: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2251"
  "^((?>\\w+)|(?>\\s+))*$"
  "now is the time for all good men to come to the aid of the party"
  '(:single-line nil)
  (list
    "now is the time for all good men to come to the aid of the party"
    "party" ) )

;;;; testinput/2252: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2252"
  "^((?>\\w+)|(?>\\s+))*$"
  "this is not a line with only words and spaces!"
  '(:single-line nil)
  nil
 )

;;;; testinput/2255: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2255"
  "(\\d+)(\\w)"
  "12345a"
  '(:single-line nil)
  (list
    "12345a"
    "12345"
    "a" ) )

;;;; testinput/2256: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2256"
  "(\\d+)(\\w)"
  "12345+"
  '(:single-line nil)
  (list
    "12345"
    "1234"
    "5" ) )

;;;; testinput/2259: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2259"
  "((?>\\d+))(\\w)"
  "12345a"
  '(:single-line nil)
  (list
    "12345a"
    "12345"
    "a" ) )

;;;; testinput/2260: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2260"
  "((?>\\d+))(\\w)"
  "12345+"
  '(:single-line nil)
  nil
 )

;;;; testinput/2263: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2263"
  "(?>a+)b"
  "aaab"
  '(:single-line nil)
  (list "aaab") )

;;;; testinput/2266: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2266"
  "((?>a+)b)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaab" ) )

;;;; testinput/2269: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2269"
  "(?>(a+))b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaa" ) )

;;;; testinput/2272: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2272"
  "(?>b)+"
  "aaabbbccc"
  '(:single-line nil)
  (list "bbb") )

;;;; testinput/2275: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2275"
  "(?>a+|b+|c+)*c"
  "aaabbbbccccd"
  '(:single-line nil)
  (list "aaabbbbc") )

;;;; testinput/2278: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2278"
  "((?>[^()]+)|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
  (list
    "abc(ade)ufh()()x"
    "x" ) )

;;;; testinput/2281: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2281"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "(abc)"
  '(:single-line nil)
  (list
    "(abc)"
    "abc" ) )

;;;; testinput/2282: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2282"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "(abc(def)xyz)"
  '(:single-line nil)
  (list
    "(abc(def)xyz)"
    "xyz" ) )

;;;; testinput/2283: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2283"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2286: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2286"
  "a(?-i)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput/2287: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2287"
  "a(?-i)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  (list "Ab") )

;;;; testinput/2288: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2288"
  "a(?-i)b"
  "aB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2289: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2289"
  "a(?-i)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2292: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2292"
  "(a (?x)b c)d e"
  "a bcd e"
  '(:single-line nil)
  (list
    "a bcd e"
    "a bc" ) )

;;;; testinput/2293: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2293"
  "(a (?x)b c)d e"
  "a b cd e"
  '(:single-line nil)
  nil
 )

;;;; testinput/2294: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2294"
  "(a (?x)b c)d e"
  "abcd e"
  '(:single-line nil)
  nil
 )

;;;; testinput/2295: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2295"
  "(a (?x)b c)d e"
  "a bcde"
  '(:single-line nil)
  nil
 )

;;;; testinput/2298: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2298"
  "(a b(?x)c d (?-x)e f)"
  "a bcde f"
  '(:single-line nil)
  (list
    "a bcde f"
    "a bcde f" ) )

;;;; testinput/2299: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2299"
  "(a b(?x)c d (?-x)e f)"
  "abcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/2302: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2302"
  "(a(?i)b)c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; testinput/2303: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2303"
  "(a(?i)b)c"
  "aBc"
  '(:single-line nil)
  (list
    "aBc"
    "aB" ) )

;;;; testinput/2304: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2304"
  "(a(?i)b)c"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2305: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2305"
  "(a(?i)b)c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2306: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2306"
  "(a(?i)b)c"
  "Abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2307: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2307"
  "(a(?i)b)c"
  "ABc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2308: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2308"
  "(a(?i)b)c"
  "ABC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2309: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2309"
  "(a(?i)b)c"
  "AbC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2312: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2312"
  "a(?i:b)c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2313: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2313"
  "a(?i:b)c"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput/2314: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2314"
  "a(?i:b)c"
  "ABC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2315: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2315"
  "a(?i:b)c"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2316: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2316"
  "a(?i:b)c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2319: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2319"
  "a(?i:b)*c"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput/2320: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2320"
  "a(?i:b)*c"
  "aBBc"
  '(:single-line nil)
  (list "aBBc") )

;;;; testinput/2321: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2321"
  "a(?i:b)*c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2322: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2322"
  "a(?i:b)*c"
  "aBBC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2325: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2325"
  "a(?=b(?i)c)\\w\\wd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput/2326: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2326"
  "a(?=b(?i)c)\\w\\wd"
  "abCd"
  '(:single-line nil)
  (list "abCd") )

;;;; testinput/2327: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2327"
  "a(?=b(?i)c)\\w\\wd"
  "aBCd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2328: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2328"
  "a(?=b(?i)c)\\w\\wd"
  "abcD"
  '(:single-line nil)
  nil
 )

;;;; testinput/2331: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2331"
  "(?s-i:more.*than).*million"
  "more than million"
  '(:ignore-case t :single-line nil)
  (list "more than million") )

;;;; testinput/2332: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2332"
  "(?s-i:more.*than).*million"
  "more than MILLION"
  '(:ignore-case t :single-line nil)
  (list "more than MILLION") )

;;;; testinput/2333: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2333"
  "(?s-i:more.*than).*million"
  (backslash "more \\n than Million")
  '(:ignore-case t :single-line nil)
  (list (backslash "more \\n than Million")) )

;;;; testinput/2334: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2334"
  "(?s-i:more.*than).*million"
  "MORE THAN MILLION"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2335: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2335"
  "(?s-i:more.*than).*million"
  (backslash "more \\n than \\n million")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2338: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2338"
  "(?:(?s-i)more.*than).*million"
  "more than million"
  '(:ignore-case t :single-line nil)
  (list "more than million") )

;;;; testinput/2339: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2339"
  "(?:(?s-i)more.*than).*million"
  "more than MILLION"
  '(:ignore-case t :single-line nil)
  (list "more than MILLION") )

;;;; testinput/2340: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2340"
  "(?:(?s-i)more.*than).*million"
  (backslash "more \\n than Million")
  '(:ignore-case t :single-line nil)
  (list (backslash "more \\n than Million")) )

;;;; testinput/2341: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2341"
  "(?:(?s-i)more.*than).*million"
  "MORE THAN MILLION"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2342: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2342"
  "(?:(?s-i)more.*than).*million"
  (backslash "more \\n than \\n million")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2345: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2345"
  "(?>a(?i)b+)+c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2346: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2346"
  "(?>a(?i)b+)+c"
  "aBbc"
  '(:single-line nil)
  (list "aBbc") )

;;;; testinput/2347: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2347"
  "(?>a(?i)b+)+c"
  "aBBc"
  '(:single-line nil)
  (list "aBBc") )

;;;; testinput/2348: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2348"
  "(?>a(?i)b+)+c"
  "Abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2349: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2349"
  "(?>a(?i)b+)+c"
  "abAb"
  '(:single-line nil)
  nil
 )

;;;; testinput/2350: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2350"
  "(?>a(?i)b+)+c"
  "abbC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2353: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2353"
  "(?=a(?i)b)\\w\\wc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2354: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2354"
  "(?=a(?i)b)\\w\\wc"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput/2355: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2355"
  "(?=a(?i)b)\\w\\wc"
  "Ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/2356: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2356"
  "(?=a(?i)b)\\w\\wc"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2357: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2357"
  "(?=a(?i)b)\\w\\wc"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2360: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2360"
  "(?<=a(?i)b)(\\w\\w)c"
  "abxxc"
  '(:single-line nil)
  (list
    "xxc"
    "xx" ) )

;;;; testinput/2361: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2361"
  "(?<=a(?i)b)(\\w\\w)c"
  "aBxxc"
  '(:single-line nil)
  (list
    "xxc"
    "xx" ) )

;;;; testinput/2362: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2362"
  "(?<=a(?i)b)(\\w\\w)c"
  "Abxxc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2363: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2363"
  "(?<=a(?i)b)(\\w\\w)c"
  "ABxxc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2364: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2364"
  "(?<=a(?i)b)(\\w\\w)c"
  "abxxC"
  '(:single-line nil)
  nil
 )

;;;; testinput/2367: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2367"
  "(?:(a)|b)(?(1)A|B)"
  "aA"
  '(:single-line nil)
  (list
    "aA"
    "a" ) )

;;;; testinput/2368: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2368"
  "(?:(a)|b)(?(1)A|B)"
  "bB"
  '(:single-line nil)
  (list "bB") )

;;;; testinput/2369: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2369"
  "(?:(a)|b)(?(1)A|B)"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput/2370: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2370"
  "(?:(a)|b)(?(1)A|B)"
  "bA"
  '(:single-line nil)
  nil
 )

;;;; testinput/2373: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2373"
  "^(a)?(?(1)a|b)+$"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput/2374: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2374"
  "^(a)?(?(1)a|b)+$"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil ) )

;;;; testinput/2375: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2375"
  "^(a)?(?(1)a|b)+$"
  "bb"
  '(:single-line nil)
  (list
    "bb"
    nil ) )

;;;; testinput/2376: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2376"
  "^(a)?(?(1)a|b)+$"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/2379: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2379"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "abc:"
  '(:single-line nil)
  (list "abc:") )

;;;; testinput/2380: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2380"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "12"
  '(:single-line nil)
  (list "12") )

;;;; testinput/2381: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2381"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput/2382: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2382"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2385: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2385"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "abc:"
  '(:single-line nil)
  (list "abc:") )

;;;; testinput/2386: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2386"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "12"
  '(:single-line nil)
  (list "12") )

;;;; testinput/2387: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2387"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput/2388: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2388"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2391: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2391"
  "(?(?<=foo)bar|cat)"
  "foobar"
  '(:single-line nil)
  (list "bar") )

;;;; testinput/2392: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2392"
  "(?(?<=foo)bar|cat)"
  "cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2393: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2393"
  "(?(?<=foo)bar|cat)"
  "fcat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2394: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2394"
  "(?(?<=foo)bar|cat)"
  "focat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2395: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2395"
  "(?(?<=foo)bar|cat)"
  "foocat"
  '(:single-line nil)
  nil
 )

;;;; testinput/2398: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2398"
  "(?(?<!foo)cat|bar)"
  "foobar"
  '(:single-line nil)
  (list "bar") )

;;;; testinput/2399: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2399"
  "(?(?<!foo)cat|bar)"
  "cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2400: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2400"
  "(?(?<!foo)cat|bar)"
  "fcat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2401: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2401"
  "(?(?<!foo)cat|bar)"
  "focat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput/2402: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2402"
  "(?(?<!foo)cat|bar)"
  "foocat"
  '(:single-line nil)
  nil
 )

;;;; testinput/2405: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2405"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput/2406: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2406"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "(abcd)"
  '(:extended-syntax t :single-line nil)
  (list
    "(abcd)"
    "(" ) )

;;;; testinput/2407: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2407"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "the quick (abcd) fox"
  '(:extended-syntax t :single-line nil)
  (list
    "the quick "
    nil ) )

;;;; testinput/2408: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2408"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "(abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput/2411: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2411"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput/2412: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2412"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "(abcd)"
  '(:extended-syntax t :single-line nil)
  (list
    "(abcd)"
    "(" ) )

;;;; testinput/2413: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2413"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "the quick (abcd) fox"
  '(:extended-syntax t :single-line nil)
  (list
    "the quick "
    nil ) )

;;;; testinput/2414: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2414"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "(abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput/2417: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2417"
  "^(?(2)a|(1)(2))+$"
  "12"
  '(:single-line nil)
  (list
    "12"
    "1"
    "2" ) )

;;;; testinput/2418: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2418"
  "^(?(2)a|(1)(2))+$"
  "12a"
  '(:single-line nil)
  (list
    "12a"
    "1"
    "2" ) )

;;;; testinput/2419: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2419"
  "^(?(2)a|(1)(2))+$"
  "12aa"
  '(:single-line nil)
  (list
    "12aa"
    "1"
    "2" ) )

;;;; testinput/2420: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2420"
  "^(?(2)a|(1)(2))+$"
  "1234"
  '(:single-line nil)
  nil
 )

;;;; testinput/2423: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2423"
  "((?i)blah)\\s+\\1"
  "blah blah"
  '(:single-line nil)
  (list
    "blah blah"
    "blah" ) )

;;;; testinput/2424: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2424"
  "((?i)blah)\\s+\\1"
  "BLAH BLAH"
  '(:single-line nil)
  (list
    "BLAH BLAH"
    "BLAH" ) )

;;;; testinput/2425: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2425"
  "((?i)blah)\\s+\\1"
  "Blah Blah"
  '(:single-line nil)
  (list
    "Blah Blah"
    "Blah" ) )

;;;; testinput/2426: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2426"
  "((?i)blah)\\s+\\1"
  "blaH blaH"
  '(:single-line nil)
  (list
    "blaH blaH"
    "blaH" ) )

;;;; testinput/2427: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2427"
  "((?i)blah)\\s+\\1"
  "blah BLAH"
  '(:single-line nil)
  nil
 )

;;;; testinput/2428: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2428"
  "((?i)blah)\\s+\\1"
  "Blah blah"
  '(:single-line nil)
  nil
 )

;;;; testinput/2429: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2429"
  "((?i)blah)\\s+\\1"
  "blaH blah"
  '(:single-line nil)
  nil
 )

;;;; testinput/2432: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2432"
  "((?i)blah)\\s+(?i:\\1)"
  "blah blah"
  '(:single-line nil)
  (list
    "blah blah"
    "blah" ) )

;;;; testinput/2433: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2433"
  "((?i)blah)\\s+(?i:\\1)"
  "BLAH BLAH"
  '(:single-line nil)
  (list
    "BLAH BLAH"
    "BLAH" ) )

;;;; testinput/2434: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2434"
  "((?i)blah)\\s+(?i:\\1)"
  "Blah Blah"
  '(:single-line nil)
  (list
    "Blah Blah"
    "Blah" ) )

;;;; testinput/2435: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2435"
  "((?i)blah)\\s+(?i:\\1)"
  "blaH blaH"
  '(:single-line nil)
  (list
    "blaH blaH"
    "blaH" ) )

;;;; testinput/2436: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2436"
  "((?i)blah)\\s+(?i:\\1)"
  "blah BLAH"
  '(:single-line nil)
  (list
    "blah BLAH"
    "blah" ) )

;;;; testinput/2437: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2437"
  "((?i)blah)\\s+(?i:\\1)"
  "Blah blah"
  '(:single-line nil)
  (list
    "Blah blah"
    "Blah" ) )

;;;; testinput/2438: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2438"
  "((?i)blah)\\s+(?i:\\1)"
  "blaH blah"
  '(:single-line nil)
  (list
    "blaH blah"
    "blaH" ) )

;;;; testinput/2441: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2441"
  "(?>a*)*"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2442: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2442"
  "(?>a*)*"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput/2443: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2443"
  "(?>a*)*"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput/2446: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2446"
  "(abc|)+"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "" ) )

;;;; testinput/2447: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2447"
  "(abc|)+"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "" ) )

;;;; testinput/2448: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2448"
  "(abc|)+"
  "abcabcabc"
  '(:single-line nil)
  (list
    "abcabcabc"
    "" ) )

;;;; testinput/2449: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2449"
  "(abc|)+"
  "xyz"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2452: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2452"
  "([a]*)*"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/2453: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2453"
  "([a]*)*"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "" ) )

;;;; testinput/2456: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2456"
  "([ab]*)*"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/2457: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2457"
  "([ab]*)*"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/2458: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2458"
  "([ab]*)*"
  "ababab"
  '(:single-line nil)
  (list
    "ababab"
    "" ) )

;;;; testinput/2459: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2459"
  "([ab]*)*"
  "aaaabcde"
  '(:single-line nil)
  (list
    "aaaab"
    "" ) )

;;;; testinput/2460: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2460"
  "([ab]*)*"
  "bbbb"
  '(:single-line nil)
  (list
    "bbbb"
    "" ) )

;;;; testinput/2463: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2463"
  "([^a]*)*"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput/2464: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2464"
  "([^a]*)*"
  "bbbb"
  '(:single-line nil)
  (list
    "bbbb"
    "" ) )

;;;; testinput/2465: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2465"
  "([^a]*)*"
  "aaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2468: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2468"
  "([^ab]*)*"
  "cccc"
  '(:single-line nil)
  (list
    "cccc"
    "" ) )

;;;; testinput/2469: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2469"
  "([^ab]*)*"
  "abab"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2472: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2472"
  "([a]*?)*"
  "a"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2473: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2473"
  "([a]*?)*"
  "aaaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2476: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2476"
  "([ab]*?)*"
  "a"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2477: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2477"
  "([ab]*?)*"
  "b"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2478: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2478"
  "([ab]*?)*"
  "abab"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2479: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2479"
  "([ab]*?)*"
  "baba"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2482: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2482"
  "([^a]*?)*"
  "b"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2483: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2483"
  "([^a]*?)*"
  "bbbb"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2484: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2484"
  "([^a]*?)*"
  "aaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2487: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2487"
  "([^ab]*?)*"
  "c"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2488: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2488"
  "([^ab]*?)*"
  "cccc"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2489: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2489"
  "([^ab]*?)*"
  "baba"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2492: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2492"
  "(?>a*)*"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2493: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2493"
  "(?>a*)*"
  "aaabcde"
  '(:single-line nil)
  (list "aaa") )

;;;; testinput/2496: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2496"
  "((?>a*))*"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "" ) )

;;;; testinput/2497: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2497"
  "((?>a*))*"
  "aabbaa"
  '(:single-line nil)
  (list
    "aa"
    "" ) )

;;;; testinput/2500: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2500"
  "((?>a*?))*"
  "aaaaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2501: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2501"
  "((?>a*?))*"
  "aabbaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/2504: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2504"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "12-sep-98"
  '(:extended-syntax t :single-line nil)
  (list "12-sep-98") )

;;;; testinput/2505: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2505"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "12-09-98"
  '(:extended-syntax t :single-line nil)
  (list "12-09-98") )

;;;; testinput/2506: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2506"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "sep-12-98"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/2509: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2509"
  "(?<=(foo))bar\\1"
  "foobarfoo"
  '(:single-line nil)
  (list
    "barfoo"
    "foo" ) )

;;;; testinput/2510: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2510"
  "(?<=(foo))bar\\1"
  "foobarfootling"
  '(:single-line nil)
  (list
    "barfoo"
    "foo" ) )

;;;; testinput/2511: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2511"
  "(?<=(foo))bar\\1"
  "foobar"
  '(:single-line nil)
  nil
 )

;;;; testinput/2512: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2512"
  "(?<=(foo))bar\\1"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/2515: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2515"
  "(?i:saturday|sunday)"
  "saturday"
  '(:single-line nil)
  (list "saturday") )

;;;; testinput/2516: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2516"
  "(?i:saturday|sunday)"
  "sunday"
  '(:single-line nil)
  (list "sunday") )

;;;; testinput/2517: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2517"
  "(?i:saturday|sunday)"
  "Saturday"
  '(:single-line nil)
  (list "Saturday") )

;;;; testinput/2518: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2518"
  "(?i:saturday|sunday)"
  "Sunday"
  '(:single-line nil)
  (list "Sunday") )

;;;; testinput/2519: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2519"
  "(?i:saturday|sunday)"
  "SATURDAY"
  '(:single-line nil)
  (list "SATURDAY") )

;;;; testinput/2520: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2520"
  "(?i:saturday|sunday)"
  "SUNDAY"
  '(:single-line nil)
  (list "SUNDAY") )

;;;; testinput/2521: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2521"
  "(?i:saturday|sunday)"
  "SunDay"
  '(:single-line nil)
  (list "SunDay") )

;;;; testinput/2524: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2524"
  "(a(?i)bc|BB)x"
  "abcx"
  '(:single-line nil)
  (list
    "abcx"
    "abc" ) )

;;;; testinput/2525: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2525"
  "(a(?i)bc|BB)x"
  "aBCx"
  '(:single-line nil)
  (list
    "aBCx"
    "aBC" ) )

;;;; testinput/2526: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2526"
  "(a(?i)bc|BB)x"
  "bbx"
  '(:single-line nil)
  (list
    "bbx"
    "bb" ) )

;;;; testinput/2527: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2527"
  "(a(?i)bc|BB)x"
  "BBx"
  '(:single-line nil)
  (list
    "BBx"
    "BB" ) )

;;;; testinput/2528: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2528"
  "(a(?i)bc|BB)x"
  "abcX"
  '(:single-line nil)
  nil
 )

;;;; testinput/2529: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2529"
  "(a(?i)bc|BB)x"
  "aBCX"
  '(:single-line nil)
  nil
 )

;;;; testinput/2530: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2530"
  "(a(?i)bc|BB)x"
  "bbX"
  '(:single-line nil)
  nil
 )

;;;; testinput/2531: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2531"
  "(a(?i)bc|BB)x"
  "BBX"
  '(:single-line nil)
  nil
 )

;;;; testinput/2534: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2534"
  "^([ab](?i)[cd]|[ef])"
  "ac"
  '(:single-line nil)
  (list
    "ac"
    "ac" ) )

;;;; testinput/2535: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2535"
  "^([ab](?i)[cd]|[ef])"
  "aC"
  '(:single-line nil)
  (list
    "aC"
    "aC" ) )

;;;; testinput/2536: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2536"
  "^([ab](?i)[cd]|[ef])"
  "bD"
  '(:single-line nil)
  (list
    "bD"
    "bD" ) )

;;;; testinput/2537: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2537"
  "^([ab](?i)[cd]|[ef])"
  "elephant"
  '(:single-line nil)
  (list
    "e"
    "e" ) )

;;;; testinput/2538: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2538"
  "^([ab](?i)[cd]|[ef])"
  "Europe"
  '(:single-line nil)
  (list
    "E"
    "E" ) )

;;;; testinput/2539: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2539"
  "^([ab](?i)[cd]|[ef])"
  "frog"
  '(:single-line nil)
  (list
    "f"
    "f" ) )

;;;; testinput/2540: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2540"
  "^([ab](?i)[cd]|[ef])"
  "France"
  '(:single-line nil)
  (list
    "F"
    "F" ) )

;;;; testinput/2541: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2541"
  "^([ab](?i)[cd]|[ef])"
  "Africa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2544: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2544"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; testinput/2545: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2545"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "aBd"
  '(:single-line nil)
  (list
    "aBd"
    "aBd" ) )

;;;; testinput/2546: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2546"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "xy"
  '(:single-line nil)
  (list
    "xy"
    "xy" ) )

;;;; testinput/2547: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2547"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "xY"
  '(:single-line nil)
  (list
    "xY"
    "xY" ) )

;;;; testinput/2548: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2548"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "zebra"
  '(:single-line nil)
  (list
    "z"
    "z" ) )

;;;; testinput/2549: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2549"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "Zambesi"
  '(:single-line nil)
  (list
    "Z"
    "Z" ) )

;;;; testinput/2550: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2550"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "aCD"
  '(:single-line nil)
  nil
 )

;;;; testinput/2551: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2551"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "XY"
  '(:single-line nil)
  nil
 )

;;;; testinput/2554: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2554"
  "(?<=foo\\n)^bar"
  (backslash "foo\\nbar")
  '(:multiple-lines t :single-line nil)
  (list "bar") )

;;;; testinput/2555: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2555"
  "(?<=foo\\n)^bar"
  "bar"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2556: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2556"
  "(?<=foo\\n)^bar"
  (backslash "baz\\nbar")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput/2559: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2559"
  "(?<=(?<!foo)bar)baz"
  "barbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput/2560: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2560"
  "(?<=(?<!foo)bar)baz"
  "barbarbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput/2561: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2561"
  "(?<=(?<!foo)bar)baz"
  "koobarbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput/2562: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2562"
  "(?<=(?<!foo)bar)baz"
  "baz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2563: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2563"
  "(?<=(?<!foo)bar)baz"
  "foobarbaz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2566: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2566"
  "^(a\\1?){4}$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2567: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2567"
  "^(a\\1?){4}$"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2568: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2568"
  "^(a\\1?){4}$"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2569: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2569"
  "^(a\\1?){4}$"
  "aaaa"
  '(:single-line nil)
  (list
    "aaaa"
    "a" ) )

;;;; testinput/2570: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2570"
  "^(a\\1?){4}$"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "a" ) )

;;;; testinput/2571: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2571"
  "^(a\\1?){4}$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "aa" ) )

;;;; testinput/2572: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2572"
  "^(a\\1?){4}$"
  "aaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaa"
    "a" ) )

;;;; testinput/2573: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2573"
  "^(a\\1?){4}$"
  "aaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2574: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2574"
  "^(a\\1?){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2575: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2575"
  "^(a\\1?){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput/2576: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2576"
  "^(a\\1?){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2577: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2577"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2578: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2578"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2579: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2579"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2580: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2580"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2581: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2581"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2584: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2584"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2585: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2585"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2586: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2586"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2587: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2587"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaa"
  '(:single-line nil)
  (list
    "aaaa"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput/2588: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2588"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "aa"
    "a"
    "a" ) )

;;;; testinput/2589: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2589"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "a"
    "aa"
    "a"
    "aa" ) )

;;;; testinput/2590: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2590"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaa"
    "a"
    "aa"
    "aaa"
    "a" ) )

;;;; testinput/2591: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2591"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2592: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2592"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2593: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2593"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "a"
    "aa"
    "aaa"
    "aaaa" ) )

;;;; testinput/2594: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2594"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2595: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2595"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2596: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2596"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2597: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2597"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2598: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2598"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2599: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2599"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2602: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2602"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2603: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2603"
  "abc"
  "xabcy"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2604: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2604"
  "abc"
  "ababc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2605: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2605"
  "abc"
  "xbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2606: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2606"
  "abc"
  "axc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2607: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2607"
  "abc"
  "abx"
  '(:single-line nil)
  nil
 )

;;;; testinput/2610: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2610"
  "ab*c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2613: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2613"
  "ab*bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2614: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2614"
  "ab*bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput/2615: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2615"
  "ab*bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2618: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2618"
  ".{1}"
  "abbbbc"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2621: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2621"
  ".{3,4}"
  "abbbbc"
  '(:single-line nil)
  (list "abbb") )

;;;; testinput/2624: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2624"
  "ab{0,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2627: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2627"
  "ab+bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput/2628: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2628"
  "ab+bc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2629: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2629"
  "ab+bc"
  "abq"
  '(:single-line nil)
  nil
 )

;;;; testinput/2634: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2634"
  "ab+bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2637: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2637"
  "ab{1,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2640: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2640"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2643: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2643"
  "ab{3,4}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput/2646: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2646"
  "ab{4,5}bc"
  "abq"
  '(:single-line nil)
  nil
 )

;;;; testinput/2647: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2647"
  "ab{4,5}bc"
  "abbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2650: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2650"
  "ab?bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput/2651: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2651"
  "ab?bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2654: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2654"
  "ab{0,1}bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2659: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2659"
  "ab?c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2662: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2662"
  "ab{0,1}c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2665: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2665"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2666: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2666"
  "^abc$"
  "abbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2667: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2667"
  "^abc$"
  "abcc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2670: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2670"
  "^abc"
  "abcc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2675: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2675"
  "abc$"
  "aabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2676: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2676"
  "abc$"
  "aabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2677: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2677"
  "abc$"
  "aabcd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2680: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2680"
  "^"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; testinput/2683: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2683"
  "$"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; testinput/2686: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2686"
  "a.c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2687: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2687"
  "a.c"
  "axc"
  '(:single-line nil)
  (list "axc") )

;;;; testinput/2690: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2690"
  "a.*c"
  "axyzc"
  '(:single-line nil)
  (list "axyzc") )

;;;; testinput/2693: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2693"
  "a[bc]d"
  "abd"
  '(:single-line nil)
  (list "abd") )

;;;; testinput/2694: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2694"
  "a[bc]d"
  "axyzd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2695: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2695"
  "a[bc]d"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput/2698: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2698"
  "a[b-d]e"
  "ace"
  '(:single-line nil)
  (list "ace") )

;;;; testinput/2701: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2701"
  "a[b-d]"
  "aac"
  '(:single-line nil)
  (list "ac") )

;;;; testinput/2704: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2704"
  "a[-b]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; testinput/2707: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2707"
  "a[b-]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; testinput/2710: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2710"
  "a]"
  "a]"
  '(:single-line nil)
  (list "a]") )

;;;; testinput/2713: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2713"
  "a[]]b"
  "a]b"
  '(:single-line nil)
  (list "a]b") )

;;;; testinput/2716: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2716"
  "a[^bc]d"
  "aed"
  '(:single-line nil)
  (list "aed") )

;;;; testinput/2717: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2717"
  "a[^bc]d"
  "abd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2718: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2718"
  "a[^bc]d"
  "abd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2721: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2721"
  "a[^-b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; testinput/2724: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2724"
  "a[^]b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; testinput/2725: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2725"
  "a[^]b]c"
  "a-c"
  '(:single-line nil)
  (list "a-c") )

;;;; testinput/2726: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2726"
  "a[^]b]c"
  "a]c"
  '(:single-line nil)
  nil
 )

;;;; testinput/2729: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2729"
  "\\ba\\b"
  "a-"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2730: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2730"
  "\\ba\\b"
  "-a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2731: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2731"
  "\\ba\\b"
  "-a-"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2734: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2734"
  "\\by\\b"
  "xy"
  '(:single-line nil)
  nil
 )

;;;; testinput/2735: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2735"
  "\\by\\b"
  "yz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2736: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2736"
  "\\by\\b"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput/2739: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2739"
  "\\Ba\\B"
  "a-"
  '(:single-line nil)
  nil
 )

;;;; testinput/2740: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2740"
  "\\Ba\\B"
  "-a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2741: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2741"
  "\\Ba\\B"
  "-a-"
  '(:single-line nil)
  nil
 )

;;;; testinput/2744: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2744"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; testinput/2747: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2747"
  "\\by\\B"
  "yz"
  '(:single-line nil)
  (list "y") )

;;;; testinput/2750: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2750"
  "\\By\\B"
  "xyz"
  '(:single-line nil)
  (list "y") )

;;;; testinput/2753: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2753"
  "\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2756: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2756"
  "\\W"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2757: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2757"
  "\\W"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2758: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2758"
  "\\W"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2761: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2761"
  "a\\sb"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; testinput/2764: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2764"
  "a\\Sb"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput/2765: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2765"
  "a\\Sb"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput/2766: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2766"
  "a\\Sb"
  "a b"
  '(:single-line nil)
  nil
 )

;;;; testinput/2769: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2769"
  "\\d"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput/2772: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2772"
  "\\D"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2773: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2773"
  "\\D"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2774: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2774"
  "\\D"
  "1"
  '(:single-line nil)
  nil
 )

;;;; testinput/2777: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2777"
  "[\\w]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2780: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2780"
  "[\\W]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2781: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2781"
  "[\\W]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2782: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2782"
  "[\\W]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/2785: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2785"
  "a[\\s]b"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; testinput/2788: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2788"
  "a[\\S]b"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput/2789: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2789"
  "a[\\S]b"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput/2790: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2790"
  "a[\\S]b"
  "a b"
  '(:single-line nil)
  nil
 )

;;;; testinput/2793: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2793"
  "[\\d]"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput/2796: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2796"
  "[\\D]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2797: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2797"
  "[\\D]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput/2798: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2798"
  "[\\D]"
  "1"
  '(:single-line nil)
  nil
 )

;;;; testinput/2801: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2801"
  "ab|cd"
  "abc"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2802: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2802"
  "ab|cd"
  "abcd"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2805: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2805"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; testinput/2810: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2810"
  "a\\(b"
  "a(b"
  '(:single-line nil)
  (list "a(b") )

;;;; testinput/2813: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2813"
  "a\\(*b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2814: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2814"
  "a\\(*b"
  "a((b"
  '(:single-line nil)
  (list "a((b") )

;;;; testinput/2817: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2817"
  "a\\\\b"
  (backslash "a\\u0008")
  '(:single-line nil)
  nil
 )

;;;; testinput/2820: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2820"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; testinput/2823: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2823"
  "(a)b(c)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "c" ) )

;;;; testinput/2826: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2826"
  "a+b+c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2829: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2829"
  "a{1,}b{1,}c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2832: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2832"
  "a.+?c"
  "abcabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/2835: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2835"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/2838: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2838"
  "(a+|b){0,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/2841: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2841"
  "(a+|b)+"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/2844: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2844"
  "(a+|b){1,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/2847: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2847"
  "(a+|b)?"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/2850: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2850"
  "(a+|b){0,1}"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/2853: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2853"
  "[^ab]*"
  "cde"
  '(:single-line nil)
  (list "cde") )

;;;; testinput/2856: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2856"
  "abc"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput/2863: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2863"
  "([abc])*d"
  "abbbcd"
  '(:single-line nil)
  (list
    "abbbcd"
    "c" ) )

;;;; testinput/2866: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2866"
  "([abc])*bcd"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "a" ) )

;;;; testinput/2869: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2869"
  "a|b|c|d|e"
  "e"
  '(:single-line nil)
  (list "e") )

;;;; testinput/2872: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2872"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; testinput/2875: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2875"
  "abcd*efg"
  "abcdefg"
  '(:single-line nil)
  (list "abcdefg") )

;;;; testinput/2878: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2878"
  "ab*"
  "xabyabbbz"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/2879: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2879"
  "ab*"
  "xayabbbz"
  '(:single-line nil)
  (list "a") )

;;;; testinput/2882: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2882"
  "(ab|cd)e"
  "abcde"
  '(:single-line nil)
  (list
    "cde"
    "cd" ) )

;;;; testinput/2885: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2885"
  "[abhgefdc]ij"
  "hij"
  '(:single-line nil)
  (list "hij") )

;;;; testinput/2890: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2890"
  "(abc|)ef"
  "abcdef"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; testinput/2893: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2893"
  "(a|b)c*d"
  "abcd"
  '(:single-line nil)
  (list
    "bcd"
    "b" ) )

;;;; testinput/2896: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2896"
  "(ab|ab*)bc"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput/2899: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2899"
  "a([bc]*)c*"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "bc" ) )

;;;; testinput/2902: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2902"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; testinput/2905: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2905"
  "a([bc]+)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; testinput/2908: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2908"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; testinput/2911: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2911"
  "a[bcd]*dcdcde"
  "adcdcde"
  '(:single-line nil)
  (list "adcdcde") )

;;;; testinput/2914: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2914"
  "a[bcd]+dcdcde"
  "abcde"
  '(:single-line nil)
  nil
 )

;;;; testinput/2915: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2915"
  "a[bcd]+dcdcde"
  "adcdcde"
  '(:single-line nil)
  nil
 )

;;;; testinput/2918: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2918"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; testinput/2921: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/2921"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; testinput/2924: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2924"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "alpha"
  '(:single-line nil)
  (list "alpha") )

;;;; testinput/2927: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2927"
  "^a(bc+|b[eh])g|.h$"
  "abh"
  '(:single-line nil)
  (list "bh") )

;;;; testinput/2930: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2930"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; testinput/2931: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2931"
  "(bc+d$|ef*g.|h?i(j|k))"
  "ij"
  '(:single-line nil)
  (list
    "ij"
    "ij"
    "j" ) )

;;;; testinput/2932: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2932"
  "(bc+d$|ef*g.|h?i(j|k))"
  "reffgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; testinput/2933: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2933"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effg"
  '(:single-line nil)
  nil
 )

;;;; testinput/2934: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2934"
  "(bc+d$|ef*g.|h?i(j|k))"
  "bcdd"
  '(:single-line nil)
  nil
 )

;;;; testinput/2937: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-cl/2937"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput/2940: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-cl/2940"
  "((((((((((a))))))))))\\10"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput/2943: 
;;;
;;;    Matched with 9 captures.
;
(test-case
  "pcre-cl/2943"
  "(((((((((a)))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput/2946: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2946"
  "multiple words of text"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput/2947: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2947"
  "multiple words of text"
  "uh-uh"
  '(:single-line nil)
  nil
 )

;;;; testinput/2950: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2950"
  "multiple words"
  "multiple words, yeah"
  '(:single-line nil)
  (list "multiple words") )

;;;; testinput/2953: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2953"
  "(.*)c(.*)"
  "abcde"
  '(:single-line nil)
  (list
    "abcde"
    "ab"
    "de" ) )

;;;; testinput/2956: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2956"
  "\\((.*), (.*)\\)"
  "(a, b)"
  '(:single-line nil)
  (list
    "(a, b)"
    "a"
    "b" ) )

;;;; testinput/2961: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2961"
  "abcd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput/2964: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2964"
  "a(bc)d"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc" ) )

;;;; testinput/2967: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2967"
  "a[-]?c"
  "ac"
  '(:single-line nil)
  (list "ac") )

;;;; testinput/2970: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2970"
  "(abc)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput/2973: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2973"
  "([a-c]*)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput/2976: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2976"
  "(a)|\\1"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/2977: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/2977"
  "(a)|\\1"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput/2978: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2978"
  "(a)|\\1"
  "x"
  '(:single-line nil)
  nil
 )

;;;; testinput/2981: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2981"
  "(([a-c])b*?\\2)*"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababb"
    "bb"
    "b" ) )

;;;; testinput/2984: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/2984"
  "(([a-c])b*?\\2){3}"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababbbcbc"
    "cbc"
    "c" ) )

;;;; testinput/2987: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/2987"
  "((\\3|b)\\2(a)x)+"
  "aaaxabaxbaaxbbax"
  '(:single-line nil)
  (list
    "bbax"
    "bbax"
    "b"
    "a" ) )

;;;; testinput/2990: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/2990"
  "((\\3|b)\\2(a)){2,}"
  "bbaababbabaaaaabbaaaabba"
  '(:single-line nil)
  (list
    "bbaaaabba"
    "bba"
    "b"
    "a" ) )

;;;; testinput/2993: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2993"
  "abc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/2994: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2994"
  "abc"
  "XABCY"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/2995: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/2995"
  "abc"
  "ABABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/2996: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2996"
  "abc"
  "aaxabxbaxbbx"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2997: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2997"
  "abc"
  "XBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2998: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2998"
  "abc"
  "AXC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/2999: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/2999"
  "abc"
  "ABX"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3002: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3002"
  "ab*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3005: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3005"
  "ab*bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3006: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3006"
  "ab*bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput/3009: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3009"
  "ab*?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3012: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3012"
  "ab{0,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3015: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3015"
  "ab+?bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput/3018: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3018"
  "ab+bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3019: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3019"
  "ab+bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3024: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3024"
  "ab+bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3027: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3027"
  "ab{1,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3030: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3030"
  "ab{1,3}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3033: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3033"
  "ab{3,4}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput/3036: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3036"
  "ab{4,5}?bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3037: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3037"
  "ab{4,5}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3040: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3040"
  "ab??bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput/3041: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3041"
  "ab??bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3044: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3044"
  "ab{0,1}?bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3049: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3049"
  "ab??c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3052: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3052"
  "ab{0,1}?c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3055: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3055"
  "^abc$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3056: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3056"
  "^abc$"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3057: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3057"
  "^abc$"
  "ABCC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3060: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3060"
  "^abc"
  "ABCC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3065: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3065"
  "abc$"
  "AABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3068: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3068"
  "^"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput/3071: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3071"
  "$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput/3074: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3074"
  "a.c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3075: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3075"
  "a.c"
  "AXC"
  '(:ignore-case t :single-line nil)
  (list "AXC") )

;;;; testinput/3078: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3078"
  "a.*?c"
  "AXYZC"
  '(:ignore-case t :single-line nil)
  (list "AXYZC") )

;;;; testinput/3081: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3081"
  "a.*c"
  "AABC"
  '(:ignore-case t :single-line nil)
  (list "AABC") )

;;;; testinput/3082: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3082"
  "a.*c"
  "AXYZD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3085: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3085"
  "a[bc]d"
  "ABD"
  '(:ignore-case t :single-line nil)
  (list "ABD") )

;;;; testinput/3088: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3088"
  "a[b-d]e"
  "ACE"
  '(:ignore-case t :single-line nil)
  (list "ACE") )

;;;; testinput/3089: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3089"
  "a[b-d]e"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3090: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3090"
  "a[b-d]e"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3093: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3093"
  "a[b-d]"
  "AAC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; testinput/3096: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3096"
  "a[-b]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; testinput/3099: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3099"
  "a[b-]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; testinput/3102: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3102"
  "a]"
  "A]"
  '(:ignore-case t :single-line nil)
  (list "A]") )

;;;; testinput/3105: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3105"
  "a[]]b"
  "A]B"
  '(:ignore-case t :single-line nil)
  (list "A]B") )

;;;; testinput/3108: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3108"
  "a[^bc]d"
  "AED"
  '(:ignore-case t :single-line nil)
  (list "AED") )

;;;; testinput/3111: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3111"
  "a[^-b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; testinput/3112: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3112"
  "a[^-b]c"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3113: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3113"
  "a[^-b]c"
  "A-C"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3116: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3116"
  "a[^]b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; testinput/3119: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3119"
  "ab|cd"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput/3120: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3120"
  "ab|cd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput/3123: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3123"
  "()ef"
  "DEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; testinput/3126: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3126"
  "$b"
  "A]C"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3127: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3127"
  "$b"
  "B"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3130: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3130"
  "a\\(b"
  "A(B"
  '(:ignore-case t :single-line nil)
  (list "A(B") )

;;;; testinput/3133: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3133"
  "a\\(*b"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput/3134: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3134"
  "a\\(*b"
  "A((B"
  '(:ignore-case t :single-line nil)
  (list "A((B") )

;;;; testinput/3137: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3137"
  "a\\\\b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3140: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3140"
  "((a))"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A" ) )

;;;; testinput/3143: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3143"
  "(a)b(c)"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A"
    "C" ) )

;;;; testinput/3146: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3146"
  "a+b+c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3149: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3149"
  "a{1,}b{1,}c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3152: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3152"
  "a.+?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3155: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3155"
  "a.*?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3158: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3158"
  "a.{0,5}?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput/3161: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3161"
  "(a+|b)*"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput/3164: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3164"
  "(a+|b){0,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput/3167: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3167"
  "(a+|b)+"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput/3170: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3170"
  "(a+|b){1,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput/3173: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3173"
  "(a+|b)?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput/3176: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3176"
  "(a+|b){0,1}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput/3179: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3179"
  "(a+|b){0,1}?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput/3182: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3182"
  "[^ab]*"
  "CDE"
  '(:ignore-case t :single-line nil)
  (list "CDE") )

;;;; testinput/3190: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3190"
  "([abc])*d"
  "ABBBCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABBBCD"
    "C" ) )

;;;; testinput/3193: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3193"
  "([abc])*bcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "A" ) )

;;;; testinput/3196: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3196"
  "a|b|c|d|e"
  "E"
  '(:ignore-case t :single-line nil)
  (list "E") )

;;;; testinput/3199: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3199"
  "(a|b|c|d|e)f"
  "EF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "E" ) )

;;;; testinput/3202: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3202"
  "abcd*efg"
  "ABCDEFG"
  '(:ignore-case t :single-line nil)
  (list "ABCDEFG") )

;;;; testinput/3205: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3205"
  "ab*"
  "XABYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput/3206: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3206"
  "ab*"
  "XAYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "A") )

;;;; testinput/3209: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3209"
  "(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "CDE"
    "CD" ) )

;;;; testinput/3212: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3212"
  "[abhgefdc]ij"
  "HIJ"
  '(:ignore-case t :single-line nil)
  (list "HIJ") )

;;;; testinput/3215: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3215"
  "^(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3218: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3218"
  "(abc|)ef"
  "ABCDEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; testinput/3221: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3221"
  "(a|b)c*d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "BCD"
    "B" ) )

;;;; testinput/3224: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3224"
  "(ab|ab*)bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A" ) )

;;;; testinput/3227: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3227"
  "a([bc]*)c*"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "BC" ) )

;;;; testinput/3230: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3230"
  "a([bc]*)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; testinput/3233: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3233"
  "a([bc]+)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; testinput/3236: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3236"
  "a([bc]*)(c+d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "B"
    "CD" ) )

;;;; testinput/3239: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3239"
  "a[bcd]*dcdcde"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  (list "ADCDCDE") )

;;;; testinput/3244: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3244"
  "(ab|a)b*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "AB" ) )

;;;; testinput/3247: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-cl/3247"
  "((a)(b)c)(d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "ABC"
    "A"
    "B"
    "D" ) )

;;;; testinput/3250: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3250"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "ALPHA"
  '(:ignore-case t :single-line nil)
  (list "ALPHA") )

;;;; testinput/3253: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3253"
  "^a(bc+|b[eh])g|.h$"
  "ABH"
  '(:ignore-case t :single-line nil)
  (list "BH") )

;;;; testinput/3256: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3256"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; testinput/3257: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3257"
  "(bc+d$|ef*g.|h?i(j|k))"
  "IJ"
  '(:ignore-case t :single-line nil)
  (list
    "IJ"
    "IJ"
    "J" ) )

;;;; testinput/3258: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3258"
  "(bc+d$|ef*g.|h?i(j|k))"
  "REFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; testinput/3259: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3259"
  "(bc+d$|ef*g.|h?i(j|k))"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3260: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3260"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFG"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3261: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3261"
  "(bc+d$|ef*g.|h?i(j|k))"
  "BCDD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3264: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-cl/3264"
  "((((((((((a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput/3267: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-cl/3267"
  "((((((((((a))))))))))\\10"
  "AA"
  '(:ignore-case t :single-line nil)
  (list
    "AA"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput/3270: 
;;;
;;;    Matched with 9 captures.
;
(test-case
  "pcre-cl/3270"
  "(((((((((a)))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput/3273: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3273"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput/3276: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3276"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))"
  "C"
  '(:ignore-case t :single-line nil)
  (list
    "C"
    "C" ) )

;;;; testinput/3279: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3279"
  "multiple words of text"
  "AA"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3280: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3280"
  "multiple words of text"
  "UH-UH"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3283: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3283"
  "multiple words"
  "MULTIPLE WORDS, YEAH"
  '(:ignore-case t :single-line nil)
  (list "MULTIPLE WORDS") )

;;;; testinput/3286: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3286"
  "(.*)c(.*)"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "ABCDE"
    "AB"
    "DE" ) )

;;;; testinput/3289: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3289"
  "\\((.*), (.*)\\)"
  "(A, B)"
  '(:ignore-case t :single-line nil)
  (list
    "(A, B)"
    "A"
    "B" ) )

;;;; testinput/3294: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3294"
  "abcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "ABCD") )

;;;; testinput/3297: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3297"
  "a(bc)d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC" ) )

;;;; testinput/3300: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3300"
  "a[-]?c"
  "AC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; testinput/3303: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3303"
  "(abc)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; testinput/3306: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3306"
  "([a-c]*)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; testinput/3309: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3309"
  "a(?!b)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput/3312: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3312"
  "a(?=d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput/3315: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3315"
  "a(?=c|d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput/3318: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3318"
  "a(?:b|c|d)(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput/3321: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3321"
  "a(?:b|c|d)*(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput/3324: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3324"
  "a(?:b|c|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput/3325: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3325"
  "a(?:b|c|d)+?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acd"
    "d" ) )

;;;; testinput/3328: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3328"
  "a(?:b|c|d)+(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput/3331: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3331"
  "a(?:b|c|d){2}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdb"
    "b" ) )

;;;; testinput/3334: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3334"
  "a(?:b|c|d){4,5}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput/3337: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3337"
  "a(?:b|c|d){4,5}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcd"
    "d" ) )

;;;; testinput/3340: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3340"
  "((foo)|(bar))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "bar"
    "foo"
    "bar" ) )

;;;; testinput/3343: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3343"
  "a(?:b|c|d){6,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput/3346: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3346"
  "a(?:b|c|d){6,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput/3349: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3349"
  "a(?:b|c|d){5,6}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput/3352: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3352"
  "a(?:b|c|d){5,6}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput/3355: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3355"
  "a(?:b|c|d){5,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput/3358: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3358"
  "a(?:b|c|d){5,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput/3361: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3361"
  "a(?:b|(c|e){1,2}?|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "c"
    "e" ) )

;;;; testinput/3364: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3364"
  "^(.+)?B"
  "AB"
  '(:single-line nil)
  (list
    "AB"
    "A" ) )

;;;; testinput/3367: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3367"
  "^([^a-z])|(\\^)$"
  "."
  '(:single-line nil)
  (list
    "."
    "." ) )

;;;; testinput/3370: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3370"
  "^[<>]&"
  "<&OUT"
  '(:single-line nil)
  (list "<&") )

;;;; testinput/3373: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3373"
  "^(a\\1?){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput/3374: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3374"
  "^(a\\1?){4}$"
  "AB"
  '(:single-line nil)
  nil
 )

;;;; testinput/3375: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3375"
  "^(a\\1?){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/3376: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3376"
  "^(a\\1?){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/3379: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3379"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput/3380: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3380"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/3381: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3381"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput/3384: 
;;;
;;;    Matched with 6 captures.
;
(test-case
  "pcre-cl/3384"
  "(?:(f)(o)(o)|(b)(a)(r))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "f"
    "o"
    "o"
    "b"
    "a"
    "r" ) )

;;;; testinput/3387: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3387"
  "(?<=a)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; testinput/3388: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3388"
  "(?<=a)b"
  "cb"
  '(:single-line nil)
  nil
 )

;;;; testinput/3389: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3389"
  "(?<=a)b"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput/3392: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3392"
  "(?<!c)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; testinput/3393: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3393"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/3394: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3394"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput/3397: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3397"
  "(?:..)*a"
  "aba"
  '(:single-line nil)
  (list "aba") )

;;;; testinput/3400: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3400"
  "(?:..)*?a"
  "aba"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3403: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3403"
  "^(?:b|a(?=(.)))*\\1"
  "abc"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput/3406: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3406"
  "^(){3,5}"
  "abc"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/3409: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3409"
  "^(a+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a" ) )

;;;; testinput/3412: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3412"
  "^((a|b)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; testinput/3415: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3415"
  "^((a|bc)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; testinput/3418: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3418"
  "(a|x)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; testinput/3421: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3421"
  "(a)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; testinput/3424: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3424"
  "(?:(?i)a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/3427: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3427"
  "((?i)a)b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/3430: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3430"
  "(?:(?i)a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; testinput/3433: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3433"
  "((?i)a)b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; testinput/3436: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3436"
  "(?:(?i)a)b"
  "cb"
  '(:single-line nil)
  nil
 )

;;;; testinput/3437: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3437"
  "(?:(?i)a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput/3442: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3442"
  "(?i:a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput/3445: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3445"
  "((?i:a))b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/3448: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3448"
  "(?i:a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; testinput/3451: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3451"
  "((?i:a))b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; testinput/3454: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3454"
  "(?i:a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput/3455: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3455"
  "(?i:a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput/3460: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3460"
  "(?:(?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput/3463: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3463"
  "((?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/3466: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3466"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput/3469: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3469"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput/3472: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3472"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput/3473: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3473"
  "(?:(?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3478: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3478"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput/3481: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3481"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput/3484: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3484"
  "(?:(?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3485: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3485"
  "(?:(?-i)a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3490: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3490"
  "(?-i:a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput/3493: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3493"
  "((?-i:a))b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput/3496: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3496"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput/3499: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3499"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput/3502: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3502"
  "(?-i:a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3503: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3503"
  "(?-i:a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3508: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3508"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput/3511: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3511"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput/3514: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3514"
  "(?-i:a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3515: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3515"
  "(?-i:a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3520: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3520"
  "((?-i:a.))b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3521: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3521"
  "((?-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput/3524: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3524"
  "((?s-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  (list
    (backslash "a\\nB")
    "a
" ) )

;;;; testinput/3527: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3527"
  "(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))"
  "cabbbb"
  '(:single-line nil)
  (list "cabbbb") )

;;;; testinput/3530: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3530"
  "(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))"
  "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
  '(:single-line nil)
  (list "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb") )

;;;; testinput/3533: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3533"
  "(ab)\\d\\1"
  "Ab4ab"
  '(:ignore-case t :single-line nil)
  (list
    "Ab4ab"
    "Ab" ) )

;;;; testinput/3534: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3534"
  "(ab)\\d\\1"
  "ab4Ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab4Ab"
    "ab" ) )

;;;; testinput/3537: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3537"
  "foo\\w*\\d{4}baz"
  "foobar1234baz"
  '(:single-line nil)
  (list "foobar1234baz") )

;;;; testinput/3540: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3540"
  "x(~~)*(?:(?:F)?)?"
  "x~~"
  '(:single-line nil)
  (list
    "x~~"
    "~~" ) )

;;;; testinput/3543: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3543"
  "^a(?#xxx){3}c"
  "aaac"
  '(:single-line nil)
  (list "aaac") )

;;;; testinput/3546: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3546"
  "^a(?#xxx)(?#xxx){3}c"
  "aaac"
  '(:single-line nil)
  (list "aaac") )

;;;; testinput/3549: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3549"
  "^a (?#xxx) (?#yyy) {3}c"
  "aaac"
  '(:extended-syntax t :single-line nil)
  (list "aaac") )

;;;; testinput/3552: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3552"
  "(?<![cd])b"
  (backslash "B\\nB")
  '(:single-line nil)
  nil
 )

;;;; testinput/3553: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3553"
  "(?<![cd])b"
  "dbcb"
  '(:single-line nil)
  nil
 )

;;;; testinput/3556: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3556"
  "(?<![cd])[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3561: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3561"
  "(?<!(c|d))[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3564: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3564"
  "(?<!cd)[ab]"
  "cdaccb"
  '(:single-line nil)
  (list "b") )

;;;; testinput/3567: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3567"
  "^(?:a?b?)*$"
  "dbcb"
  '(:single-line nil)
  nil
 )

;;;; testinput/3568: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3568"
  "^(?:a?b?)*$"
  "a--"
  '(:single-line nil)
  nil
 )

;;;; testinput/3571: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3571"
  "((?s)^a(.))((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "a\\nb")
    "a
"
    "
"
    "b" ) )

;;;; testinput/3574: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3574"
  "((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput/3577: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3577"
  "(?m)^b"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "b") )

;;;; testinput/3580: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3580"
  "(?m)^(b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput/3583: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3583"
  "((?m)^b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput/3586: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3586"
  "\\n((?m)^b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    (backslash "\\nb")
    "b" ) )

;;;; testinput/3589: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3589"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; testinput/3590: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3590"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; testinput/3593: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3593"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; testinput/3594: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3594"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; testinput/3599: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3599"
  "()^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput/3600: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3600"
  "()^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput/3603: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3603"
  "((?m)^b)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput/3608: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3608"
  "(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3611: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3611"
  "(x)?(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3612: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3612"
  "(x)?(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3615: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3615"
  "(x)?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; testinput/3618: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3618"
  "()?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; testinput/3623: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3623"
  "()?(?(1)a|b)"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/3626: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3626"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; testinput/3627: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3627"
  "^(\\()?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list
    "blah"
    nil ) )

;;;; testinput/3628: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3628"
  "^(\\()?blah(?(1)(\\)))$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3629: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3629"
  "^(\\()?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil
 )

;;;; testinput/3630: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3630"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil
 )

;;;; testinput/3633: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3633"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; testinput/3634: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3634"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list "blah") )

;;;; testinput/3635: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3635"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil
 )

;;;; testinput/3636: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3636"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil
 )

;;;; testinput/3641: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3641"
  "(?(?!a)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3644: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3644"
  "(?(?=a)b|a)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3645: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3645"
  "(?(?=a)b|a)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3648: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3648"
  "(?(?=a)a|b)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3651: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3651"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; testinput/3656: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3656"
  "(\\w+:)+"
  "one:"
  '(:single-line nil)
  (list
    "one:"
    "one:" ) )

;;;; testinput/3659: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3659"
  "$(?<=^(a))"
  "a"
  '(:single-line nil)
  (list
    ""
    "a" ) )

;;;; testinput/3662: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3662"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; testinput/3665: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3665"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput/3666: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3666"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput/3669: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3669"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; testinput/3670: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3670"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; testinput/3673: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3673"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; testinput/3676: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3676"
  "(a*)b+"
  "caab"
  '(:single-line nil)
  (list
    "aab"
    "aa" ) )

;;;; testinput/3679: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3679"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; testinput/3680: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3680"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; testinput/3681: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3681"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil
 )

;;;; testinput/3682: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3682"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil
 )

;;;; testinput/3685: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3685"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; testinput/3690: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3690"
  "(?>a+)b"
  "aaab"
  '(:single-line nil)
  (list "aaab") )

;;;; testinput/3693: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3693"
  "([[:]+)"
  "a:[b]:"
  '(:single-line nil)
  (list
    ":["
    ":[" ) )

;;;; testinput/3696: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3696"
  "([[=]+)"
  "a=[b]="
  '(:single-line nil)
  (list
    "=["
    "=[" ) )

;;;; testinput/3699: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3699"
  "([[.]+)"
  "a.[b]."
  '(:single-line nil)
  (list
    ".["
    ".[" ) )

;;;; testinput/3702: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3702"
  "((?>a+)b)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaab" ) )

;;;; testinput/3705: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3705"
  "(?>(a+))b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaa" ) )

;;;; testinput/3708: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3708"
  "((?>[^()]+)|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
  (list
    "abc(ade)ufh()()x"
    "x" ) )

;;;; testinput/3711: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3711"
  "a\\Z"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput/3712: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3712"
  "a\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput/3715: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3715"
  "b\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "b") )

;;;; testinput/3720: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3720"
  "b\\Z"
  (backslash "a\\nb")
  '(:single-line nil)
  (list "b") )

;;;; testinput/3723: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3723"
  "b\\z"
  (backslash "a\\nb")
  '(:single-line nil)
  (list "b") )

;;;; testinput/3726: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3726"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput/3727: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3727"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "" ) )

;;;; testinput/3728: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3728"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a-b"
  '(:single-line nil)
  (list
    "a-b"
    "" ) )

;;;; testinput/3729: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3729"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "0-9"
  '(:single-line nil)
  (list
    "0-9"
    "" ) )

;;;; testinput/3730: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3730"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.b"
  '(:single-line nil)
  (list
    "a.b"
    "" ) )

;;;; testinput/3731: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3731"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "5.6.7"
  '(:single-line nil)
  (list
    "5.6.7"
    "" ) )

;;;; testinput/3732: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3732"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox"
  '(:single-line nil)
  (list
    "the.quick.brown.fox"
    "" ) )

;;;; testinput/3733: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3733"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a100.b200.300c"
  '(:single-line nil)
  (list
    "a100.b200.300c"
    "" ) )

;;;; testinput/3734: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3734"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "12-ab.1245"
  '(:single-line nil)
  (list
    "12-ab.1245"
    "" ) )

;;;; testinput/3735: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3735"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  ""
  '(:single-line nil)
  nil
 )

;;;; testinput/3736: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3736"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  ".a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3737: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3737"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "-a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3738: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3738"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a-"
  '(:single-line nil)
  nil
 )

;;;; testinput/3739: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3739"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a."
  '(:single-line nil)
  nil
 )

;;;; testinput/3740: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3740"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a_b"
  '(:single-line nil)
  nil
 )

;;;; testinput/3741: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3741"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.-"
  '(:single-line nil)
  nil
 )

;;;; testinput/3742: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3742"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.."
  '(:single-line nil)
  nil
 )

;;;; testinput/3743: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3743"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "ab..bc"
  '(:single-line nil)
  nil
 )

;;;; testinput/3744: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3744"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox-"
  '(:single-line nil)
  nil
 )

;;;; testinput/3745: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3745"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox."
  '(:single-line nil)
  nil
 )

;;;; testinput/3746: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3746"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox_"
  '(:single-line nil)
  nil
 )

;;;; testinput/3747: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3747"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox+"
  '(:single-line nil)
  nil
 )

;;;; testinput/3750: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3750"
  "(?>.*)(?<=(abcd|wxyz))"
  "alphabetabcd"
  '(:single-line nil)
  (list
    "alphabetabcd"
    "abcd" ) )

;;;; testinput/3751: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3751"
  "(?>.*)(?<=(abcd|wxyz))"
  "endingwxyz"
  '(:single-line nil)
  (list
    "endingwxyz"
    "wxyz" ) )

;;;; testinput/3752: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3752"
  "(?>.*)(?<=(abcd|wxyz))"
  "a rather long string that doesn't end with one of them"
  '(:single-line nil)
  nil
 )

;;;; testinput/3755: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3755"
  "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark otherword"
  '(:single-line nil)
  (list "word cat dog elephant mussel cow horse canary baboon snake shark otherword") )

;;;; testinput/3756: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3756"
  "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark"
  '(:single-line nil)
  nil
 )

;;;; testinput/3759: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3759"
  "word (?>[a-zA-Z0-9]+ ){0,30}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope"
  '(:single-line nil)
  nil
 )

;;;; testinput/3762: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3762"
  "(?<=\\d{3}(?!999))foo"
  "999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3763: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3763"
  "(?<=\\d{3}(?!999))foo"
  "123999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3764: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3764"
  "(?<=\\d{3}(?!999))foo"
  "123abcfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/3767: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3767"
  "(?<=(?!...999)\\d{3})foo"
  "999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3768: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3768"
  "(?<=(?!...999)\\d{3})foo"
  "123999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3769: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3769"
  "(?<=(?!...999)\\d{3})foo"
  "123abcfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput/3772: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3772"
  "(?<=\\d{3}(?!999)...)foo"
  "123abcfoo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3773: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3773"
  "(?<=\\d{3}(?!999)...)foo"
  "123456foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3774: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3774"
  "(?<=\\d{3}(?!999)...)foo"
  "123999foo"
  '(:single-line nil)
  nil
 )

;;;; testinput/3777: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3777"
  "(?<=\\d{3}...)(?<!999)foo"
  "123abcfoo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3778: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3778"
  "(?<=\\d{3}...)(?<!999)foo"
  "123456foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput/3779: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3779"
  "(?<=\\d{3}...)(?<!999)foo"
  "123999foo"
  '(:single-line nil)
  nil
 )

;;;; testinput/3786: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3786"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput/3787: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3787"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput/3788: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3788"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href='abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href='abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput/3795: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3795"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput/3796: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3796"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput/3797: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3797"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href       =       'abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href       =       'abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput/3804: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3804"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput/3805: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3805"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput/3806: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3806"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href       =       'abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href       =       'abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput/3809: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3809"
  "((Z)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    "Z" ) )

;;;; testinput/3812: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-cl/3812"
  "(Z()|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    "" ) )

;;;; testinput/3815: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-cl/3815"
  "(Z(())|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    ""
    "" ) )

;;;; testinput/3818: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3818"
  "((?>Z)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A" ) )

;;;; testinput/3821: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3821"
  "((?>)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput/3824: 
;;;
;;;    
;
(test-case/g
  "pcre-cl/3824"
  "a*"
  "abbab"
  '(:single-line nil)
  (list "a"
        ""
        ""
        "a"
        ""
        "" )
    "" )

;;;; testinput/3827: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3827"
  "^[a-\\d]"
  "abcde"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3828: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3828"
  "^[a-\\d]"
  "-things"
  '(:single-line nil)
  (list "-") )

;;;; testinput/3829: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3829"
  "^[a-\\d]"
  "0digit"
  '(:single-line nil)
  (list "0") )

;;;; testinput/3830: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3830"
  "^[a-\\d]"
  "bcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/3833: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3833"
  "^[\\d-a]"
  "abcde"
  '(:single-line nil)
  (list "a") )

;;;; testinput/3834: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3834"
  "^[\\d-a]"
  "-things"
  '(:single-line nil)
  (list "-") )

;;;; testinput/3835: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3835"
  "^[\\d-a]"
  "0digit"
  '(:single-line nil)
  (list "0") )

;;;; testinput/3836: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3836"
  "^[\\d-a]"
  "bcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/3839: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3839"
  "(?<=abc).*(?=def)"
  "abcdef"
  '(:single-line nil)
  (list "") )

;;;; testinput/3840: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3840"
  "(?<=abc).*(?=def)"
  "abcxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3841: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3841"
  "(?<=abc).*(?=def)"
  "abcxdefxdef"
  '(:single-line nil)
  (list "xdefx") )

;;;; testinput/3844: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3844"
  "(?<=abc).*?(?=def)"
  "abcdef"
  '(:single-line nil)
  (list "") )

;;;; testinput/3845: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3845"
  "(?<=abc).*?(?=def)"
  "abcxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3846: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3846"
  "(?<=abc).*?(?=def)"
  "abcxdefxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3849: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3849"
  "(?<=abc).+(?=def)"
  "abcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/3850: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3850"
  "(?<=abc).+(?=def)"
  "abcxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3851: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3851"
  "(?<=abc).+(?=def)"
  "abcxdefxdef"
  '(:single-line nil)
  (list "xdefx") )

;;;; testinput/3854: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3854"
  "(?<=abc).+?(?=def)"
  "abcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput/3855: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3855"
  "(?<=abc).+?(?=def)"
  "abcxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3856: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3856"
  "(?<=abc).+?(?=def)"
  "abcxdefxdef"
  '(:single-line nil)
  (list "x") )

;;;; testinput/3859: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3859"
  "(?<=\\b)(.*)"
  "-abcdef"
  '(:single-line nil)
  (list
    "abcdef"
    "abcdef" ) )

;;;; testinput/3860: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3860"
  "(?<=\\b)(.*)"
  "abcdef"
  '(:single-line nil)
  (list
    "abcdef"
    "abcdef" ) )

;;;; testinput/3863: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3863"
  "(?<=\\B)(.*)"
  "-abcdef"
  '(:single-line nil)
  (list
    "-abcdef"
    "-abcdef" ) )

;;;; testinput/3864: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-cl/3864"
  "(?<=\\B)(.*)"
  "abcdef"
  '(:single-line nil)
  (list
    "bcdef"
    "bcdef" ) )

;;;; testinput/3867: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3867"
  "^'[ab]'"
  "'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3868: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3868"
  "^'[ab]'"
  "'b'"
  '(:single-line nil)
  (list "'b'") )

;;;; testinput/3869: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3869"
  "^'[ab]'"
  "x'a'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3870: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3870"
  "^'[ab]'"
  "'a'x"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3871: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3871"
  "^'[ab]'"
  "'ab'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3874: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3874"
  "^'[ab]'$"
  "'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3875: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3875"
  "^'[ab]'$"
  "'b'"
  '(:single-line nil)
  (list "'b'") )

;;;; testinput/3876: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3876"
  "^'[ab]'$"
  "x'a'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3877: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3877"
  "^'[ab]'$"
  "'a'x"
  '(:single-line nil)
  nil
 )

;;;; testinput/3878: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3878"
  "^'[ab]'$"
  "'ab'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3881: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3881"
  "'[ab]'$"
  "'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3882: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3882"
  "'[ab]'$"
  "'b'"
  '(:single-line nil)
  (list "'b'") )

;;;; testinput/3883: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3883"
  "'[ab]'$"
  "x'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3884: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3884"
  "'[ab]'$"
  "'a'x"
  '(:single-line nil)
  nil
 )

;;;; testinput/3885: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3885"
  "'[ab]'$"
  "'ab'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3888: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3888"
  "'[ab]'"
  "'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3889: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3889"
  "'[ab]'"
  "'b'"
  '(:single-line nil)
  (list "'b'") )

;;;; testinput/3890: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3890"
  "'[ab]'"
  "x'a'"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3891: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3891"
  "'[ab]'"
  "'a'x"
  '(:single-line nil)
  (list "'a'") )

;;;; testinput/3892: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3892"
  "'[ab]'"
  "'ab'"
  '(:single-line nil)
  nil
 )

;;;; testinput/3895: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3895"
  "abc\\E"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/3896: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3896"
  "abc\\E"
  "abcE"
  '(:single-line nil)
  (list "abc") )

;;;; testinput/3899: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3899"
  "abc[\\Ex]"
  "abcx"
  '(:single-line nil)
  (list "abcx") )

;;;; testinput/3900: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3900"
  "abc[\\Ex]"
  "abcE"
  '(:single-line nil)
  nil
 )

;;;; testinput/3903: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3903"
  "^\\Qa*\\E$"
  "a*"
  '(:single-line nil)
  (list "a*") )

;;;; testinput/3904: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3904"
  "^\\Qa*\\E$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput/3907: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3907"
  "\\Qa*x\\E"
  "a*x"
  '(:single-line nil)
  (list "a*x") )

;;;; testinput/3908: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3908"
  "\\Qa*x\\E"
  "a*"
  '(:single-line nil)
  nil
 )

;;;; testinput/3911: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3911"
  "\\Qa*x"
  "a*x"
  '(:single-line nil)
  (list "a*x") )

;;;; testinput/3912: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3912"
  "\\Qa*x"
  "a*"
  '(:single-line nil)
  nil
 )

;;;; testinput/3915: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3915"
  "\\Q\\Qa*x\\E\\E"
  "a*x"
  '(:single-line nil)
  nil
 )

;;;; testinput/3916: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3916"
  "\\Q\\Qa*x\\E\\E"
  "a\\*x"
  '(:single-line nil)
  (list "a\\*x") )

;;;; testinput/3919: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3919"
  "\\Q\\Qa*x\\E"
  "a*x"
  '(:single-line nil)
  nil
 )

;;;; testinput/3920: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3920"
  "\\Q\\Qa*x\\E"
  "a\\*x"
  '(:single-line nil)
  (list "a\\*x") )

;;;; testinput/3923: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3923"
  "a\\Q[x\\E]"
  "a[x]"
  '(:single-line nil)
  (list "a[x]") )

;;;; testinput/3924: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3924"
  "a\\Q[x\\E]"
  "ax"
  '(:single-line nil)
  nil
 )

;;;; testinput/3928: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3928"
  (backslash "a#comment\\Q...\\n{2}")
  "a"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/3929: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3929"
  (backslash "a#comment\\Q...\\n{2}")
  "aa"
  '(:extended-syntax t :single-line nil)
  (list "aa") )

;;;; testinput/3933: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3933"
  (backslash "a(?#comment\\Q...\\n){2}")
  "a"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput/3934: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3934"
  (backslash "a(?#comment\\Q...\\n){2}")
  "aa"
  '(:extended-syntax t :single-line nil)
  (list "aa") )

;;;; testinput/3938: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3938"
  (backslash "(?x)a#\\Q\\n.")
  "a."
  '(:single-line nil)
  (list "a.") )

;;;; testinput/3939: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3939"
  (backslash "(?x)a#\\Q\\n.")
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput/3942: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3942"
  "ab(?=.*q)cd"
  "abcdxklqj"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput/3945: 
;;;
;;;    Not matched
;
(test-case
  "pcre-cl/3945"
  "a(?!.*$)b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput/3948: 
;;;
;;;    Matched
;
(test-case
  "pcre-cl/3948"
  ".{2}[a-z]"
  "Axi"
  '(:single-line nil)
  (list "Axi") )

; EOF
